From 085fb6b4f055ca63197e3830df4d373f6c3cf21b Mon Sep 17 00:00:00 2001 From: MilkBlock <2386925778@qq.com> Date: Wed, 22 Apr 2026 23:08:54 +0800 Subject: [PATCH 1/8] feat(runtime): make tx facades session-aware Make tx_rx_vt_pr-generated Tx facades resolve through explicit sessions or a default fallback session instead of a process-wide true singleton. This lifts the pseudo-singleton runtime from example-local prototype code into src/instances, updates the macro expansion to generate session-aware facades, migrates the constant-prop pseudo-singleton examples to the library API, and adds regression tests for session isolation, async routing, and reset-for-bench behavior. Focused verification: - cargo test --test session_aware_tx --test pseudo_singleton_constant_prop - cargo run --example constant_prop_pseudo_singleton - cargo run --example constant_prop_pseudo_singleton_async - subagent review: no findings --- Cargo.toml | 2 +- README.md | 20 +- benches/insert_1000_func.rs | 2 +- .../eggplant_rewrite/extract_vec_bench.rs | 2 +- .../eggplant_rewrite/math_microbenchmark.rs | 2 +- .../eggplant_rewrite/merge_during_rebuild.rs | 2 +- .../eggplant_rewrite/repro_665_set_union.rs | 2 +- .../runners/eggplant_rewrite/vec_builtins.rs | 2 +- .../runners/eggplant_rewrite/web_demo_set.rs | 4 +- .../eggplant_rewrite/web_demo_unify.rs | 2 +- benches/runners/generated/eggcc_extraction.rs | 2 +- benches/runners/generated/taylor51.rs | 2 +- examples/add_rule_proof_smoke.rs | 2 +- examples/constant_prop_proof.rs | 2 +- ...ted_snapshot_constant_prop_continuation.rs | 13 +- examples/rustsat_common_subexpr.rs | 2 +- examples/rustsat_optimize_expression.rs | 2 +- .../support/pseudo_singleton_constant_prop.rs | 218 +++--- examples/support/pseudo_singleton_runtime.rs | 433 ------------ src/instances/mod.rs | 82 ++- src/instances/pseudo_singleton.rs | 641 ++++++++++++++++++ src/prelude.rs | 5 +- src/test.rs | 197 ++++-- src/wrap/mod.rs | 1 + tests/indexed_pat_decode.rs | 2 +- ...ted_snapshot_constant_prop_continuation.rs | 13 +- tests/persisted_snapshot_corpus_validation.rs | 10 +- tests/persisted_snapshot_fixture_stability.rs | 26 +- tests/pseudo_singleton_constant_prop.rs | 10 + tests/rustsat_common_subexpr.rs | 2 +- tests/rustsat_optimize_expression.rs | 4 +- .../serialized_artifact_fixture_stability.rs | 8 +- tests/session_aware_tx.rs | 252 +++++++ tests/timestamp_match_filter.rs | 4 +- tests/typed_extract_cost_model.rs | 6 +- tests/typed_extract_dynamic_cost.rs | 2 +- 36 files changed, 1297 insertions(+), 684 deletions(-) delete mode 100644 examples/support/pseudo_singleton_runtime.rs create mode 100644 src/instances/pseudo_singleton.rs create mode 100644 tests/session_aware_tx.rs diff --git a/Cargo.toml b/Cargo.toml index 90db178..b0fe4cb 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -48,13 +48,13 @@ crossbeam.workspace = true indexmap.workspace = true sha2 = "0.10" num = "0.4" +tokio = { version = "1.48.0", features = ["rt", "rt-multi-thread", "macros", "sync"] } [dev-dependencies] divan = { package = "codspeed-divan-compat", version = "4.4.1" } glob = "0.3" mimalloc = "0.1" rayon = "1.10" -tokio = { version = "1.48.0", features = ["rt", "rt-multi-thread", "macros", "sync"] } egglog_upstream = { package = "egglog", git = "https://github.com/egraphs-good/egglog.git", rev = "3595b21efb18dbf9936d258acab48324a3dc6b04" } egglog_upstream_reports = { package = "egglog-reports", git = "https://github.com/egraphs-good/egglog.git", rev = "3595b21efb18dbf9936d258acab48324a3dc6b04" } diff --git a/README.md b/README.md index b027829..4adfde3 100644 --- a/README.md +++ b/README.md @@ -141,15 +141,21 @@ fn main() { } ``` -If you want to study a "pseudo-singleton" design instead of the default true-global -runtime style, see: +`tx_rx_vt_pr!` now generates a session-aware `Tx` facade by default. + +- Calls like `MyTx::add_rule(...)`, `MyTx::run_ruleset(...)`, and `MyTx::canonical_raw(...)` + resolve against the current active session when one is bound. +- If no explicit session is active, they fall back to a lazily created default session, + preserving the old singleton-style workflow. + +If you want to study the explicit session API in practice, see: - `examples/constant_prop_pseudo_singleton.rs` - `examples/constant_prop_pseudo_singleton_async.rs` -These examples keep a singleton-looking facade API (`MyTx::...`), but route operations -through an explicit session handle. The async version only supports explicit wrapper-based -entry (`run_async` / `spawn_async`); it does not claim ambient async-task inheritance. +These examples use the default session-aware `MyTx::...` API together with explicit +session handles. The async version only supports explicit wrapper-based entry +(`run_async` / `spawn_async`); it does not claim ambient async-task inheritance. Finally, the following EGraph is generated, and you can see that the root node value is directly derived. @@ -277,9 +283,9 @@ cargo run --example action_sample_recorder ### Pseudo-Singleton Session Examples -- **`examples/constant_prop_pseudo_singleton.rs`**: Demonstrates a pseudo-singleton session model for constant propagation. The API still looks like `MyTx::...`, but the active runtime is selected by an explicit session handle. +- **`examples/constant_prop_pseudo_singleton.rs`**: Demonstrates the default session-aware `tx_rx_vt_pr!` facade for constant propagation. The API still looks like `MyTx::...`, but the active runtime is selected by an explicit session handle. -- **`examples/constant_prop_pseudo_singleton_async.rs`**: Demonstrates the same pseudo-singleton idea for explicit async wrapper entry points (`run_async`, `spawn_async`) and mixed sync/async re-entry. +- **`examples/constant_prop_pseudo_singleton_async.rs`**: Demonstrates the same session-aware model for explicit async wrapper entry points (`run_async`, `spawn_async`) and mixed sync/async re-entry. Run them with: diff --git a/benches/insert_1000_func.rs b/benches/insert_1000_func.rs index 1f942b1..3f671b0 100644 --- a/benches/insert_1000_func.rs +++ b/benches/insert_1000_func.rs @@ -10,7 +10,7 @@ struct f { #[divan::bench(sample_count = 10)] fn eggplant_insert_1000_func() { - MyTx::sgl().reset_for_bench(); + MyTx::reset_for_bench(); let seed = MyTx::new_ruleset("insert_1000_func_seed"); MyTx::add_rule( diff --git a/benches/runners/eggplant_rewrite/extract_vec_bench.rs b/benches/runners/eggplant_rewrite/extract_vec_bench.rs index 4a084f1..f633fec 100644 --- a/benches/runners/eggplant_rewrite/extract_vec_bench.rs +++ b/benches/runners/eggplant_rewrite/extract_vec_bench.rs @@ -6,7 +6,7 @@ tx_rx_vt_pr!(MyTxExtract, MyPatRecExtract); include!("../generated/extract_vec_bench.rs"); pub fn bench() { - MyTxExtract::sgl().reset_for_bench(); + MyTxExtract::reset_for_bench(); let large_expr = build_large_expr(); large_expr.commit(); diff --git a/benches/runners/eggplant_rewrite/math_microbenchmark.rs b/benches/runners/eggplant_rewrite/math_microbenchmark.rs index 3309942..9e725c5 100644 --- a/benches/runners/eggplant_rewrite/math_microbenchmark.rs +++ b/benches/runners/eggplant_rewrite/math_microbenchmark.rs @@ -527,7 +527,7 @@ pub fn run_and_collect_stats(breakdown: bool) -> MathMicrobenchmarkStats { let rewrite_callback_stats = breakdown.then(|| Arc::new(Mutex::new(BTreeMap::new()))); let t = Instant::now(); - MyTxMath::sgl().reset_for_bench(); + MyTxMath::reset_for_bench(); if breakdown { eprintln!( "[bench-breakdown] math-microbenchmark reset_for_bench: {:?}", diff --git a/benches/runners/eggplant_rewrite/merge_during_rebuild.rs b/benches/runners/eggplant_rewrite/merge_during_rebuild.rs index dddbc01..93d435d 100644 --- a/benches/runners/eggplant_rewrite/merge_during_rebuild.rs +++ b/benches/runners/eggplant_rewrite/merge_during_rebuild.rs @@ -18,7 +18,7 @@ struct distance { tx_rx_vt_pr!(MyTxDist, MyPatRecDist); pub fn bench() { - MyTxDist::sgl().reset_for_bench(); + MyTxDist::reset_for_bench(); // Seed facts (ports `tests/merge-during-rebuild.egg`). let seed = MyTxDist::new_ruleset("merge_during_rebuild_seed"); diff --git a/benches/runners/eggplant_rewrite/repro_665_set_union.rs b/benches/runners/eggplant_rewrite/repro_665_set_union.rs index e7cb48d..271d8a5 100644 --- a/benches/runners/eggplant_rewrite/repro_665_set_union.rs +++ b/benches/runners/eggplant_rewrite/repro_665_set_union.rs @@ -32,7 +32,7 @@ fn step_pat() -> StepPat { } pub fn bench() { - MyTxRepro::sgl().reset_for_bench(); + MyTxRepro::reset_for_bench(); let seed = MyTxRepro::new_ruleset("repro_665_seed"); MyTxRepro::add_rule( diff --git a/benches/runners/eggplant_rewrite/vec_builtins.rs b/benches/runners/eggplant_rewrite/vec_builtins.rs index 3ea60dc..b5e477a 100644 --- a/benches/runners/eggplant_rewrite/vec_builtins.rs +++ b/benches/runners/eggplant_rewrite/vec_builtins.rs @@ -114,7 +114,7 @@ fn pat_vec_check_vec_set() -> CheckIVecPat { } pub fn bench() { - MyTxVec::sgl().reset_for_bench(); + MyTxVec::reset_for_bench(); let rs = MyTxVec::new_ruleset("vec_checks"); diff --git a/benches/runners/eggplant_rewrite/web_demo_set.rs b/benches/runners/eggplant_rewrite/web_demo_set.rs index 38c23a2..5735061 100644 --- a/benches/runners/eggplant_rewrite/web_demo_set.rs +++ b/benches/runners/eggplant_rewrite/web_demo_set.rs @@ -246,7 +246,7 @@ pub fn bench() { let t_total = Instant::now(); let t = Instant::now(); - MyTxSet::sgl().reset_for_bench(); + MyTxSet::reset_for_bench(); if breakdown { eprintln!( "[bench-breakdown] web-demo/set reset_for_bench (checks): {:?}", @@ -427,7 +427,7 @@ pub fn bench() { // Isolate the reify portion from the builtin checks to match the egglog source structure // (the `let/run/check` block is independent of the earlier `check`s). let t = Instant::now(); - MyTxSet::sgl().reset_for_bench(); + MyTxSet::reset_for_bench(); if breakdown { eprintln!( "[bench-breakdown] web-demo/set reset_for_bench (reify): {:?}", diff --git a/benches/runners/eggplant_rewrite/web_demo_unify.rs b/benches/runners/eggplant_rewrite/web_demo_unify.rs index a7739f3..63a5912 100644 --- a/benches/runners/eggplant_rewrite/web_demo_unify.rs +++ b/benches/runners/eggplant_rewrite/web_demo_unify.rs @@ -55,7 +55,7 @@ fn lit_eq_mul_pat() -> LitEqMulPat { } pub fn bench() { - MyTxUnify::sgl().reset_for_bench(); + MyTxUnify::reset_for_bench(); let seed = MyTxUnify::new_ruleset("unify_seed"); MyTxUnify::add_rule( diff --git a/benches/runners/generated/eggcc_extraction.rs b/benches/runners/generated/eggcc_extraction.rs index 4589cb8..5872599 100644 --- a/benches/runners/generated/eggcc_extraction.rs +++ b/benches/runners/generated/eggcc_extraction.rs @@ -6602,7 +6602,7 @@ fn pat_pat0201() -> Pat0201 { } pub fn bench() { - MyTxEggccExtraction::sgl().reset_for_bench(); + MyTxEggccExtraction::reset_for_bench(); let fast = MyTxEggccExtraction::new_ruleset("fast-analyses"); let subst = MyTxEggccExtraction::new_ruleset("subst"); diff --git a/benches/runners/generated/taylor51.rs b/benches/runners/generated/taylor51.rs index b95a68b..2b5ca0e 100644 --- a/benches/runners/generated/taylor51.rs +++ b/benches/runners/generated/taylor51.rs @@ -96,7 +96,7 @@ struct ToExtract { } pub fn bench() { - MyTxTaylor51::sgl().reset_for_bench(); + MyTxTaylor51::reset_for_bench(); let seed = MyTxTaylor51::new_ruleset("taylor51_seed"); MyTxTaylor51::add_rule( diff --git a/examples/add_rule_proof_smoke.rs b/examples/add_rule_proof_smoke.rs index 3570616..59880be 100644 --- a/examples/add_rule_proof_smoke.rs +++ b/examples/add_rule_proof_smoke.rs @@ -19,7 +19,7 @@ impl SingletonGetter for MyTxProof { impl eggplant::wrap::NonPatRecSgl for MyTxProof { fn egraph() -> std::sync::Arc> { - Self::sgl().egraph.clone() + ::egraph() } } diff --git a/examples/constant_prop_proof.rs b/examples/constant_prop_proof.rs index f4fef56..d7a850f 100644 --- a/examples/constant_prop_proof.rs +++ b/examples/constant_prop_proof.rs @@ -28,7 +28,7 @@ impl SingletonGetter for MyTxProof { impl eggplant::wrap::NonPatRecSgl for MyTxProof { fn egraph() -> std::sync::Arc> { - Self::sgl().egraph.clone() + ::egraph() } } diff --git a/examples/persisted_snapshot_constant_prop_continuation.rs b/examples/persisted_snapshot_constant_prop_continuation.rs index 8b9b98b..36beff5 100644 --- a/examples/persisted_snapshot_constant_prop_continuation.rs +++ b/examples/persisted_snapshot_constant_prop_continuation.rs @@ -58,7 +58,8 @@ fn snapshot_path() -> PathBuf { fn dump_snapshot_to_disk(path: &PathBuf) { let snapshot = { - let egraph = ContTx::sgl().egraph.lock().unwrap(); + let egraph_handle = ContTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) }; fs::write(path, serde_json::to_string_pretty(&snapshot).unwrap()).unwrap(); @@ -96,7 +97,7 @@ fn canonical_eq(lhs: &Expr, rhs_const: i64) -> bool { fn main() { env_logger::init(); - ContTx::sgl().reset_for_bench(); + ContTx::reset_for_bench(); let ruleset = register_constant_prop_rules(); let mul: Expr = Mul::new(&Const::new(3), &Const::new(2)); @@ -112,15 +113,17 @@ fn main() { dump_snapshot_to_disk(&path); println!("snapshot: {}", path.display()); - ContTx::sgl().reset_for_bench(); + ContTx::reset_for_bench(); let ruleset = register_constant_prop_rules(); let snapshot = load_snapshot_from_disk(&path); { - let mut egraph = ContTx::sgl().egraph.lock().unwrap(); + let egraph_handle = ContTx::egraph(); + let mut egraph = egraph_handle.lock().unwrap(); restore_persisted_snapshot_v1(&mut egraph, &snapshot).unwrap(); } let restored_snapshot = { - let egraph = ContTx::sgl().egraph.lock().unwrap(); + let egraph_handle = ContTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) }; assert!( diff --git a/examples/rustsat_common_subexpr.rs b/examples/rustsat_common_subexpr.rs index 8142115..af7548c 100644 --- a/examples/rustsat_common_subexpr.rs +++ b/examples/rustsat_common_subexpr.rs @@ -11,7 +11,7 @@ tx_rx_vt_pr!(RustsatCseTx, RustsatCsePatRec); fn main() { let _ = env_logger::try_init(); - RustsatCseTx::sgl().reset_for_bench(); + RustsatCseTx::reset_for_bench(); let shared_leaf = CLeaf::::new(0); let shared_l1 = CInc::::new(&shared_leaf); diff --git a/examples/rustsat_optimize_expression.rs b/examples/rustsat_optimize_expression.rs index 300180d..ba38886 100644 --- a/examples/rustsat_optimize_expression.rs +++ b/examples/rustsat_optimize_expression.rs @@ -19,7 +19,7 @@ tx_rx_vt_pr!(RustsatDemoTx, RustsatDemoPatRec); fn main() { let _ = env_logger::try_init(); - RustsatDemoTx::sgl().reset_for_bench(); + RustsatDemoTx::reset_for_bench(); let leaf = Leaf::::new(7); let cheap = CheapWrap::::new(&leaf); diff --git a/examples/support/pseudo_singleton_constant_prop.rs b/examples/support/pseudo_singleton_constant_prop.rs index e05c683..935a5e9 100644 --- a/examples/support/pseudo_singleton_constant_prop.rs +++ b/examples/support/pseudo_singleton_constant_prop.rs @@ -1,10 +1,6 @@ -#[path = "pseudo_singleton_runtime.rs"] -mod pseudo_singleton_runtime; - -use eggplant::prelude::*; -use std::sync::{Arc, Barrier}; - -pub use pseudo_singleton_runtime::{MyTx, Session, new_session}; +use eggplant::{prelude::*, tx_rx_vt_pr}; +use std::sync::{Arc, Barrier, mpsc}; +use std::time::Duration; #[eggplant::dsl] pub enum Expr { @@ -13,11 +9,12 @@ pub enum Expr { Add { l: Expr, r: Expr }, } +tx_rx_vt_pr!(MyTx, MyPatRec); + macro_rules! prop { ($rule_name:expr, $ty:ident, $op:tt, $pat_name:ident, $ruleset:ident) => {{ - let rule_name = $rule_name; MyTx::add_rule( - &rule_name, + $rule_name, $ruleset, || { let l = Const::query(); @@ -40,11 +37,8 @@ macro_rules! prop { } pub fn register_constant_prop_rules() -> RuleSetId { - const RULESET_CACHE_KEY: &str = "constant_prop"; - const RULESET_NAME: &str = "constant_prop_pseudo_singleton"; - - pseudo_singleton_runtime::get_or_register_ruleset(RULESET_CACHE_KEY, || { - let ruleset = MyTx::new_ruleset(RULESET_NAME); + eggplant::instances::pseudo_singleton::get_or_register_ruleset::("constant_prop", || { + let ruleset = MyTx::new_ruleset("constant_prop_pseudo_singleton"); prop!("AddPat", Add, +, AddPat, ruleset); prop!("MulPat", Mul, *, MulPat, ruleset); ruleset @@ -52,7 +46,7 @@ pub fn register_constant_prop_rules() -> RuleSetId { } fn current_snapshot() -> PersistedSnapshot { - let egraph = ::egraph(); + let egraph = MyTx::egraph(); let egraph = egraph.lock().unwrap(); build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) } @@ -104,25 +98,27 @@ fn fold_active_mul_add_expr(lhs: i64, rhs: i64, addend: i64) -> i64 { expected } -pub fn fold_mul_add_expr(session: &Session, lhs: i64, rhs: i64, addend: i64) -> i64 { +pub fn fold_mul_add_expr(session: &Session, lhs: i64, rhs: i64, addend: i64) -> i64 { session.run(|| fold_active_mul_add_expr(lhs, rhs, addend)) } -pub fn session_has_const(session: &Session, needle: i64) -> bool { +pub fn session_has_const(session: &Session, needle: i64) -> bool { session.run(|| current_session_has_const(needle)) } pub fn registers_rules_twice_in_same_session() { - let session = new_session(); + let session = MyTx::new_session(); session.run(|| { - let ruleset1 = register_constant_prop_rules(); - let ruleset2 = register_constant_prop_rules(); + let ruleset1 = session.get_or_register_ruleset("constant_prop", || { + let ruleset = MyTx::new_ruleset("constant_prop_pseudo_singleton"); + prop!("AddPat", Add, +, AddPat, ruleset); + prop!("MulPat", Mul, *, MulPat, ruleset); + ruleset + }); + let ruleset2 = session.get_or_register_ruleset("constant_prop", || unreachable!()); - assert_eq!( - ruleset1.0, ruleset2.0, - "re-registering in one session should reuse the cached ruleset" - ); + assert_eq!(ruleset1.0, ruleset2.0); let expr: Expr = Add::new(&Mul::new(&Const::new(2), &Const::new(8)), &Const::new(1)); @@ -130,51 +126,39 @@ pub fn registers_rules_twice_in_same_session() { let _ = MyTx::run_ruleset(ruleset1, RunConfig::Sat); let _ = MyTx::run_ruleset(ruleset2, RunConfig::Sat); - - assert!( - canonical_eq(&expr, 17), - "re-registering rules in one session should remain usable" - ); + assert!(canonical_eq(&expr, 17)); }); } pub fn concurrent_sessions_can_register_rules_on_different_threads() { - let left = new_session(); - let right = new_session(); + let left = MyTx::new_session(); + let right = MyTx::new_session(); let left_thread = left.spawn(move || fold_active_mul_add_expr(3, 2, 4)); let right_thread = right.spawn(move || fold_active_mul_add_expr(5, 5, 1)); assert_eq!(left_thread.join().unwrap(), 10); assert_eq!(right_thread.join().unwrap(), 26); - - assert!( - session_has_const(&left, 10), - "left session should keep its folded constant after threaded execution" - ); - assert!( - !session_has_const(&left, 26), - "left session should remain isolated from the right session" - ); - assert!( - session_has_const(&right, 26), - "right session should keep its folded constant after threaded execution" - ); - assert!( - !session_has_const(&right, 10), - "right session should remain isolated from the left session" - ); + assert!(session_has_const(&left, 10)); + assert!(!session_has_const(&left, 26)); + assert!(session_has_const(&right, 26)); + assert!(!session_has_const(&right, 10)); } pub fn same_session_concurrent_registration_is_safe() { - let session = new_session(); + let session = MyTx::new_session(); let barrier = Arc::new(Barrier::new(2)); let left_session = session.clone(); let left_barrier = Arc::clone(&barrier); let left = session.spawn(move || { left_barrier.wait(); - let ruleset = register_constant_prop_rules(); + let ruleset = left_session.get_or_register_ruleset("constant_prop", || { + let ruleset = MyTx::new_ruleset("constant_prop_pseudo_singleton"); + prop!("AddPat", Add, +, AddPat, ruleset); + prop!("MulPat", Mul, *, MulPat, ruleset); + ruleset + }); let folded = fold_active_mul_add_expr(3, 2, 4); ( ruleset.0.to_owned(), @@ -187,7 +171,12 @@ pub fn same_session_concurrent_registration_is_safe() { let right_barrier = Arc::clone(&barrier); let right = session.spawn(move || { right_barrier.wait(); - let ruleset = register_constant_prop_rules(); + let ruleset = right_session.get_or_register_ruleset("constant_prop", || { + let ruleset = MyTx::new_ruleset("constant_prop_pseudo_singleton"); + prop!("AddPat", Add, +, AddPat, ruleset); + prop!("MulPat", Mul, *, MulPat, ruleset); + ruleset + }); let folded = fold_active_mul_add_expr(2, 8, 1); ( ruleset.0.to_owned(), @@ -198,17 +187,62 @@ pub fn same_session_concurrent_registration_is_safe() { let left = left.join().unwrap(); let right = right.join().unwrap(); - - assert_eq!( - left.0, right.0, - "same-session concurrent registration should converge on one cached ruleset" - ); + assert_eq!(left.0, right.0); assert_eq!(left.1, 10); assert_eq!(right.1, 17); assert!(left.2); assert!(right.2); } +pub fn nested_ruleset_registration_is_safe() { + let session = MyTx::new_session(); + let (sender, receiver) = mpsc::sync_channel(1); + + let sender_thread = sender.clone(); + let session_for_thread = session.clone(); + let handle = session.spawn(move || { + let outer = session_for_thread.get_or_register_ruleset("outer_constant_prop", || { + let inner = session_for_thread.get_or_register_ruleset("inner_constant_prop", || { + MyTx::new_ruleset("inner_constant_prop_ruleset") + }); + let outer = MyTx::new_ruleset("outer_constant_prop_ruleset"); + assert_ne!(inner.0, outer.0); + outer + }); + sender_thread.send(outer.0.to_owned()).unwrap(); + }); + + let outer_ruleset = receiver.recv_timeout(Duration::from_secs(1)).unwrap(); + assert_eq!(outer_ruleset, "outer_constant_prop_ruleset"); + handle.join().unwrap(); +} + +pub fn nested_same_key_registration_panics_instead_of_deadlocking() { + let session = MyTx::new_session(); + + let panic = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + session.run(|| { + let _ = session.get_or_register_ruleset("same_key_ruleset", || { + let _ = session.get_or_register_ruleset("same_key_ruleset", || { + MyTx::new_ruleset("same_key_inner_ruleset") + }); + MyTx::new_ruleset("same_key_outer_ruleset") + }); + }); + })) + .expect_err("same-key nested registration should fail fast"); + + let message = if let Some(message) = panic.downcast_ref::<&str>() { + (*message).to_owned() + } else if let Some(message) = panic.downcast_ref::() { + message.clone() + } else { + String::new() + }; + + assert!(message.contains("reentrant ruleset registration")); +} + pub fn async_sessions_can_survive_yield_and_spawn() { let runtime = tokio::runtime::Builder::new_multi_thread() .worker_threads(2) @@ -217,8 +251,8 @@ pub fn async_sessions_can_survive_yield_and_spawn() { .unwrap(); runtime.block_on(async { - let left = new_session(); - let right = new_session(); + let left = MyTx::new_session(); + let right = MyTx::new_session(); let left_value = left .run_async(async { @@ -234,29 +268,10 @@ pub fn async_sessions_can_survive_yield_and_spawn() { }); assert_eq!(right_join.await.unwrap(), 26); - let left_has_10 = left - .run_async(async { current_session_has_const(10) }) - .await; - let left_has_26 = left - .run_async(async { current_session_has_const(26) }) - .await; - let right_has_26 = right - .run_async(async { current_session_has_const(26) }) - .await; - let right_has_10 = right - .run_async(async { current_session_has_const(10) }) - .await; - - assert!(left_has_10, "left async session should retain Const 10"); - assert!( - !left_has_26, - "left async session should remain isolated from the right async session" - ); - assert!(right_has_26, "right async session should retain Const 26"); - assert!( - !right_has_10, - "right async session should remain isolated from the left async session" - ); + assert!(left.run_async(async { current_session_has_const(10) }).await); + assert!(!left.run_async(async { current_session_has_const(26) }).await); + assert!(right.run_async(async { current_session_has_const(26) }).await); + assert!(!right.run_async(async { current_session_has_const(10) }).await); }); } @@ -267,49 +282,28 @@ pub fn sync_run_can_override_outer_async_session() { .unwrap(); runtime.block_on(async { - let outer = new_session(); - let inner = new_session(); + let outer = MyTx::new_session(); + let inner = MyTx::new_session(); outer .run_async(async { tokio::task::yield_now().await; - assert_eq!(fold_mul_add_expr(&inner, 5, 5, 1), 26); - - assert!( - session_has_const(&inner, 26), - "inner session should receive the sync override work" - ); - assert!( - !session_has_const(&outer, 26), - "outer async session should not accidentally receive inner sync work" - ); + assert!(session_has_const(&inner, 26)); + assert!(!session_has_const(&outer, 26)); }) .await; }); } pub fn two_isolated_sessions_keep_separate_egraphs_with_handles() { - let left = new_session(); - let right = new_session(); + let left = MyTx::new_session(); + let right = MyTx::new_session(); assert_eq!(fold_mul_add_expr(&left, 3, 2, 4), 10); assert_eq!(fold_mul_add_expr(&right, 5, 5, 1), 26); - - assert!( - session_has_const(&left, 10), - "left session should keep its own derived constant" - ); - assert!( - !session_has_const(&left, 26), - "left session should not see the right session's folded constant" - ); - assert!( - session_has_const(&right, 26), - "right session should keep its own derived constant" - ); - assert!( - !session_has_const(&right, 10), - "right session should not inherit the left session's folded constant" - ); + assert!(session_has_const(&left, 10)); + assert!(!session_has_const(&left, 26)); + assert!(session_has_const(&right, 26)); + assert!(!session_has_const(&right, 10)); } diff --git a/examples/support/pseudo_singleton_runtime.rs b/examples/support/pseudo_singleton_runtime.rs deleted file mode 100644 index b447445..0000000 --- a/examples/support/pseudo_singleton_runtime.rs +++ /dev/null @@ -1,433 +0,0 @@ -use eggplant::egglog::EGraph; -use eggplant::instances::{pat_rec::PatRecorder, tx_rx_vt_pr::TxRxVTPR}; -use eggplant::prelude::{RuleSetId, SingletonGetter}; -use eggplant::wrap::{EgglogNode, EgglogTy, FactsBuilder, IntoConstraintFact, PatRec, PatRecSgl}; -use std::cell::RefCell; -use std::collections::HashMap; -use std::future::Future; -use std::sync::{ - Arc, Mutex, - atomic::{AtomicUsize, Ordering}, -}; - -pub type Runtime = TxRxVTPR; - -static NEXT_SESSION_ID: AtomicUsize = AtomicUsize::new(0); -static NEXT_BINDING_ORDER: AtomicUsize = AtomicUsize::new(0); - -struct SessionState { - id: usize, - runtime: Runtime, - pat_recorder: PatRecorder, - rulesets: Mutex>, -} - -impl SessionState { - fn new() -> Self { - Self { - id: NEXT_SESSION_ID.fetch_add(1, Ordering::Relaxed), - runtime: Runtime::new(), - pat_recorder: PatRecorder::new(), - rulesets: Mutex::new(HashMap::new()), - } - } -} - -#[derive(Clone)] -struct SessionBinding { - state: Arc, - order: usize, -} - -impl SessionBinding { - fn new(state: Arc) -> Self { - Self { - state, - order: NEXT_BINDING_ORDER.fetch_add(1, Ordering::Relaxed), - } - } -} - -tokio::task_local! { - static CURRENT_SESSION_TASK: SessionBinding; -} - -thread_local! { - static CURRENT_SESSION_THREAD: RefCell> = const { RefCell::new(None) }; -} - -fn current_state() -> Arc { - let thread_binding = CURRENT_SESSION_THREAD.with(|slot| slot.borrow().clone()); - let task_binding = CURRENT_SESSION_TASK.try_with(Clone::clone).ok(); - - match (thread_binding, task_binding) { - (Some(thread), Some(task)) => { - if thread.order > task.order { - thread.state - } else { - task.state - } - } - (Some(thread), None) => thread.state, - (None, Some(task)) => task.state, - (None, None) => panic!( - "no pseudo-singleton session is active; enter via Session::run, Session::run_async, Session::spawn, or Session::spawn_async" - ), - } -} - -#[derive(Clone)] -pub struct Session { - state: Arc, -} - -impl Session { - pub fn raw(&self) -> usize { - self.state.id - } - - pub fn run(&self, f: impl FnOnce() -> R) -> R { - CURRENT_SESSION_THREAD.with(|slot| { - let previous = slot.replace(Some(SessionBinding::new(Arc::clone(&self.state)))); - let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(f)); - slot.replace(previous); - match result { - Ok(value) => value, - Err(payload) => std::panic::resume_unwind(payload), - } - }) - } - - pub async fn run_async(&self, fut: impl Future) -> R { - CURRENT_SESSION_TASK - .scope(SessionBinding::new(Arc::clone(&self.state)), fut) - .await - } - - pub fn spawn( - &self, - f: impl FnOnce() -> R + Send + 'static, - ) -> std::thread::JoinHandle { - let session = self.clone(); - std::thread::spawn(move || session.run(f)) - } - - pub fn spawn_async( - &self, - fut: impl Future + Send + 'static, - ) -> tokio::task::JoinHandle { - let binding = SessionBinding::new(Arc::clone(&self.state)); - tokio::spawn(CURRENT_SESSION_TASK.scope(binding, fut)) - } -} - -pub fn new_session() -> Session { - Session { - state: Arc::new(SessionState::new()), - } -} - -pub(super) fn current_session() -> Session { - Session { - state: current_state(), - } -} - -pub(super) fn get_or_register_ruleset( - key: &'static str, - build: impl FnOnce() -> RuleSetId, -) -> RuleSetId { - let state = current_state(); - let mut rulesets = state.rulesets.lock().unwrap(); - if let Some(existing) = rulesets.get(key).copied() { - return existing; - } - - let ruleset = build(); - rulesets.insert(key, ruleset); - ruleset -} - -fn with_runtime(f: impl FnOnce(&Runtime) -> R) -> R { - let state = current_state(); - f(&state.runtime) -} - -fn with_pat_recorder(f: impl FnOnce(&PatRecorder) -> R) -> R { - let state = current_state(); - f(&state.pat_recorder) -} - -pub struct MyTxFacade; -static MY_TX_FACADE: MyTxFacade = MyTxFacade; - -pub struct MyPatRecFacade; -static MY_PAT_REC_FACADE: MyPatRecFacade = MyPatRecFacade; - -pub struct MyTx; - -impl SingletonGetter for MyTx { - type RetTy = MyTxFacade; - - fn sgl() -> &'static MyTxFacade { - &MY_TX_FACADE - } -} - -impl eggplant::wrap::NonPatRecSgl for MyTx { - fn egraph() -> std::sync::Arc> { - with_runtime(|runtime| runtime.egraph.clone()) - } -} - -pub struct MyPatRec; - -impl SingletonGetter for MyPatRec { - type RetTy = MyPatRecFacade; - - fn sgl() -> &'static MyPatRecFacade { - &MY_PAT_REC_FACADE - } -} - -impl eggplant::wrap::WithPatRecSgl for MyTx { - type PatRecSgl = MyPatRec; -} - -impl eggplant::wrap::WithRxSgl for MyPatRec { - type RxSgl = MyTx; -} - -impl eggplant::wrap::NodeOwner for MyTxFacade { - type OwnerSpecDataInNode = (); -} - -impl eggplant::wrap::NodeDropper for MyTxFacade {} - -impl eggplant::wrap::NodeSetter for MyTxFacade { - fn on_set(&self, _node: &mut (impl EgglogNode + 'static)) {} -} - -impl eggplant::wrap::VersionCtl for MyTxFacade { - fn locate_latest(&self, node: eggplant::wrap::Sym) -> eggplant::wrap::Sym { - with_runtime(|runtime| runtime.locate_latest(node)) - } - - fn locate_next(&self, node: eggplant::wrap::Sym) -> eggplant::wrap::Sym { - with_runtime(|runtime| runtime.locate_next(node)) - } - - fn locate_prev(&self, node: eggplant::wrap::Sym) -> eggplant::wrap::Sym { - with_runtime(|runtime| runtime.locate_prev(node)) - } - - fn set_latest(&self, node: &mut eggplant::wrap::Sym) { - with_runtime(|runtime| runtime.set_latest(node)) - } - - fn set_next(&self, node: &mut eggplant::wrap::Sym) { - with_runtime(|runtime| runtime.set_next(node)) - } - - fn set_prev(&self, node: &mut eggplant::wrap::Sym) { - with_runtime(|runtime| runtime.set_prev(node)) - } -} - -impl eggplant::wrap::Tx for MyTxFacade { - fn send(&self, sended: eggplant::wrap::TxCommand) { - with_runtime(|runtime| runtime.send(sended)) - } - - fn on_new(&self, node: &(impl EgglogNode + 'static)) { - with_runtime(|runtime| runtime.on_new(node)) - } - - fn on_func_set<'a, F: eggplant::wrap::EgglogFunc>( - &self, - input: ::Ref<'a>, - output: ::Ref<'a>, - ) { - with_runtime(|runtime| runtime.on_func_set::(input, output)) - } - - fn on_union(&self, node1: &(impl EgglogNode + 'static), node2: &(impl EgglogNode + 'static)) { - with_runtime(|runtime| runtime.on_union(node1, node2)) - } - - fn canonical_raw(&self, node1: &(impl EgglogNode + 'static)) -> eggplant::egglog::Value { - with_runtime(|runtime| runtime.canonical_raw(node1)) - } -} - -impl eggplant::wrap::TxCommit for MyTxFacade { - fn on_stage(&self, node: &T) { - with_runtime(|runtime| runtime.on_stage(node)) - } - - fn on_commit_op_hook( - &self, - node: &T, - hook: Option>, - ) { - with_runtime(|runtime| runtime.on_commit_op_hook(node, hook)) - } -} - -impl eggplant::wrap::Rx for MyTxFacade { - fn on_func_get<'a, F: eggplant::wrap::EgglogFunc>( - &self, - input: ::Ref<'a>, - ) -> F::Output { - with_runtime(|runtime| runtime.on_func_get::(input)) - } - - fn on_funcs_get<'a, 'b, F: eggplant::wrap::EgglogFunc>( - &self, - max_size: Option, - ) -> Vec<( - ::Ref<'b>, - ::Ref<'b>, - )> { - with_runtime(|runtime| runtime.on_funcs_get::(max_size)) - } - - fn on_pull_sym(&self, sym: eggplant::wrap::Sym) -> eggplant::wrap::SymLit { - with_runtime(|runtime| runtime.on_pull_sym::(sym)) - } - - fn on_pull_value( - &self, - value: eggplant::wrap::Value, - ) -> eggplant::wrap::SymLit { - with_runtime(|runtime| runtime.on_pull_value(value)) - } -} - -impl eggplant::wrap::rule::RuleRunner for MyTxFacade { - fn add_rule>( - &self, - rule_name: &str, - rule_set: eggplant::wrap::RuleSetId, - pat: impl Fn() -> P, - action: impl Fn(&eggplant::wrap::PRRuleCtx, &P::Valued) - + Send - + Sync - + 'static - + Clone, - ctx_hook: Option>, - ) { - with_runtime(|runtime| runtime.add_rule::

(rule_name, rule_set, pat, action, ctx_hook)) - } - - fn new_ruleset(&self, rule_set: &'static str) -> eggplant::wrap::RuleSetId { - with_runtime(|runtime| { - >::new_ruleset(runtime, rule_set) - }) - } - - fn run_ruleset( - &self, - rule_set_id: eggplant::wrap::RuleSetId, - run_config: eggplant::wrap::RunConfig, - ) -> egglog_reports::RunReport { - with_runtime(|runtime| { - >::run_ruleset( - runtime, - rule_set_id, - run_config, - ) - }) - } - - fn value(&self, node: &T) -> eggplant::wrap::Value { - with_runtime(|runtime| { - >::value(runtime, node) - }) - } -} - -impl eggplant::wrap::NodeOwner for MyPatRecFacade { - type OwnerSpecDataInNode = u32; -} - -impl eggplant::wrap::NodeDropper for MyPatRecFacade { - fn on_drop(&self, dropped: &mut (impl EgglogNode + 'static)) { - with_pat_recorder(|pat_recorder| pat_recorder.on_drop(dropped)) - } -} - -impl eggplant::wrap::NodeSetter for MyPatRecFacade { - fn on_set(&self, node: &mut (impl EgglogNode + 'static)) { - with_pat_recorder(|pat_recorder| pat_recorder.on_set(node)) - } -} - -impl eggplant::wrap::Tx for MyPatRecFacade { - fn send(&self, sended: eggplant::wrap::TxCommand) { - with_pat_recorder(|pat_recorder| pat_recorder.send(sended)) - } - - fn on_new(&self, node: &(impl EgglogNode + 'static)) { - with_pat_recorder(|pat_recorder| pat_recorder.on_new(node)) - } - - fn on_func_set<'a, F: eggplant::wrap::EgglogFunc>( - &self, - input: ::Ref<'a>, - output: ::Ref<'a>, - ) { - with_pat_recorder(|pat_recorder| pat_recorder.on_func_set::(input, output)) - } - - fn on_union(&self, node1: &(impl EgglogNode + 'static), node2: &(impl EgglogNode + 'static)) { - with_pat_recorder(|pat_recorder| pat_recorder.on_union(node1, node2)) - } - - fn canonical_raw(&self, node1: &(impl EgglogNode + 'static)) -> eggplant::egglog::Value { - with_pat_recorder(|pat_recorder| pat_recorder.canonical_raw(node1)) - } -} - -impl PatRec for MyPatRecFacade { - type MetaTy = (); - - fn on_new_query_leaf(&self, node: &(impl EgglogNode + 'static)) { - with_pat_recorder(|pat_recorder| pat_recorder.on_new_query_leaf(node)) - } - - fn on_new_constraint(&self, constraint: impl IntoConstraintFact) { - with_pat_recorder(|pat_recorder| pat_recorder.on_new_constraint(constraint)) - } - - fn on_new_table_fact( - &self, - query_table: eggplant::wrap::TableName, - vars: Vec<(eggplant::wrap::VarName, eggplant::wrap::SortName)>, - ) { - with_pat_recorder(|pat_recorder| pat_recorder.on_new_table_fact(query_table, vars)) - } - - fn on_new_relation_fact( - &self, - query_table: eggplant::wrap::TableName, - vars: Vec<(eggplant::wrap::VarName, eggplant::wrap::SortName)>, - ) { - with_pat_recorder(|pat_recorder| pat_recorder.on_new_relation_fact(query_table, vars)) - } - - fn on_record_start(&self) { - with_pat_recorder(|pat_recorder| pat_recorder.on_record_start()) - } - - fn on_record_end( - &self, - pat_vars: &impl eggplant::wrap::PatVars, - ) -> eggplant::wrap::PatId { - with_pat_recorder(|pat_recorder| pat_recorder.on_record_end(pat_vars)) - } - - fn pat2fact_builder(&self, pat_id: eggplant::wrap::PatId) -> FactsBuilder { - with_pat_recorder(|pat_recorder| pat_recorder.pat2fact_builder(pat_id)) - } -} diff --git a/src/instances/mod.rs b/src/instances/mod.rs index b287bd4..470226e 100644 --- a/src/instances/mod.rs +++ b/src/instances/mod.rs @@ -1,4 +1,5 @@ pub mod pat_rec; +pub mod pseudo_singleton; pub mod tx; pub mod tx_minimal; pub mod tx_rx_vt; @@ -145,8 +146,85 @@ macro_rules! basic_tx_rx_vt_pr { #[macro_export] macro_rules! tx_rx_vt_pr { ($tx_name:ident, $pat_rec_name:ident) => { - eggplant::basic_tx_rx_vt_pr!($tx_name); - eggplant::basic_patttern_recorder!($pat_rec_name); + pub struct $tx_name; + pub struct $pat_rec_name; + + impl $tx_name { + pub fn new_session() -> eggplant::instances::pseudo_singleton::Session { + ::new_session() + } + + pub fn default_session() -> eggplant::instances::pseudo_singleton::Session { + ::default_session() + } + + pub fn egraph() -> std::sync::Arc> { + eggplant::instances::pseudo_singleton::egraph::() + } + + pub fn reset_for_bench() { + eggplant::instances::pseudo_singleton::reset_for_bench::() + } + } + + impl eggplant::instances::pseudo_singleton::SessionAwarePatRecMarker for $pat_rec_name { + type TxMarker = $tx_name; + type MetaTy = + ::MetaTy; + } + + impl eggplant::instances::pseudo_singleton::SessionAwareTxMarker for $tx_name { + type Runtime = eggplant::instances::tx_rx_vt_pr::TxRxVTPR; + type PatRecorder = eggplant::instances::pat_rec::PatRecorder; + type PatRecMarker = $pat_rec_name; + + fn new_runtime() -> Self::Runtime { + eggplant::instances::tx_rx_vt_pr::TxRxVTPR::new() + } + + fn new_pat_recorder() -> Self::PatRecorder { + eggplant::instances::pat_rec::PatRecorder::new() + } + + fn runtime_egraph( + runtime: &Self::Runtime, + ) -> std::sync::Arc> { + runtime.egraph.clone() + } + + fn reset_runtime_for_bench(runtime: &Self::Runtime) { + runtime.reset_for_bench() + } + } + + impl eggplant::prelude::SingletonGetter for $tx_name { + type RetTy = eggplant::instances::pseudo_singleton::SessionTxFacade<$tx_name>; + + fn sgl() -> &'static Self::RetTy { + static FACADE: eggplant::instances::pseudo_singleton::SessionTxFacade<$tx_name> = + eggplant::instances::pseudo_singleton::SessionTxFacade::new(); + &FACADE + } + } + + impl eggplant::prelude::SingletonGetter for $pat_rec_name { + type RetTy = + eggplant::instances::pseudo_singleton::SessionPatRecFacade<$pat_rec_name>; + + fn sgl() -> &'static Self::RetTy { + static FACADE: eggplant::instances::pseudo_singleton::SessionPatRecFacade< + $pat_rec_name, + > = eggplant::instances::pseudo_singleton::SessionPatRecFacade::new(); + &FACADE + } + } + + impl eggplant::wrap::NonPatRecSgl for $tx_name { + fn egraph() -> std::sync::Arc> { + eggplant::instances::pseudo_singleton::egraph::<$tx_name>() + } + } + impl eggplant::wrap::WithPatRecSgl for $tx_name { type PatRecSgl = $pat_rec_name; } diff --git a/src/instances/pseudo_singleton.rs b/src/instances/pseudo_singleton.rs new file mode 100644 index 0000000..0538d45 --- /dev/null +++ b/src/instances/pseudo_singleton.rs @@ -0,0 +1,641 @@ +use crate::wrap::{ + EgglogFunc, EgglogFuncInputs, EgglogFuncOutput, EgglogNode, EgglogRelation, EgglogTy, + FactsBuilder, FromBase, LocateVersion, NodeDropper, NodeOwner, NodeSetter, PatId, PatRec, + PatRecSgl, PatVars, RuleCtxHook, RuleRunner, RuleSetId, RunConfig, Rx, SortName, Sym, TableName, + ToDot, Tx, TxCommand, TxCommit, Value, VarName, VersionCtl, +}; +use egglog::EGraph; +use egglog_reports::RunReport; +use std::any::{Any, TypeId}; +use std::cell::RefCell; +use std::collections::HashMap; +use std::future::Future; +use std::marker::PhantomData; +use std::ops::Deref; +use std::sync::{ + Arc, Condvar, Mutex, OnceLock, + atomic::{AtomicUsize, Ordering}, +}; +use std::thread::ThreadId; + +type ErasedState = Arc; + +#[derive(Clone)] +struct ErasedSessionBinding { + state: ErasedState, + order: usize, +} + +impl ErasedSessionBinding { + fn new(state: Arc>) -> Self { + Self { + state, + order: NEXT_BINDING_ORDER.fetch_add(1, Ordering::Relaxed), + } + } +} + +static NEXT_BINDING_ORDER: AtomicUsize = AtomicUsize::new(0); +static DEFAULT_SESSIONS: OnceLock>> = OnceLock::new(); + +tokio::task_local! { + static CURRENT_SESSION_TASKS: RefCell>; +} + +thread_local! { + static CURRENT_SESSION_THREADS: RefCell> = RefCell::new(HashMap::new()); +} + +#[derive(Clone, Copy)] +enum RulesetRegistration { + Building { owner: ThreadId }, + Ready(RuleSetId), +} + +struct SessionState { + runtime: Tx::Runtime, + pat_recorder: Mutex, + rulesets: Mutex>, + rulesets_cv: Condvar, +} + +impl SessionState { + fn new() -> Self { + Self { + runtime: Tx::new_runtime(), + pat_recorder: Mutex::new(Tx::new_pat_recorder()), + rulesets: Mutex::new(HashMap::new()), + rulesets_cv: Condvar::new(), + } + } +} + +fn type_key() -> TypeId { + TypeId::of::() +} + +fn erase_state(state: Arc>) -> ErasedState { + state +} + +fn downcast_state(state: ErasedState) -> Arc> { + state.downcast::>().unwrap_or_else(|_| { + panic!( + "pseudo-singleton state type mismatch for {}", + std::any::type_name::() + ) + }) +} + +fn default_state() -> Arc> { + let key = type_key::(); + let mut registry = DEFAULT_SESSIONS + .get_or_init(|| Mutex::new(HashMap::new())) + .lock() + .unwrap(); + if let Some(existing) = registry.get(&key) { + return downcast_state::(Arc::clone(existing)); + } + + let state = Arc::new(SessionState::::new()); + registry.insert(key, erase_state(Arc::clone(&state))); + state +} + +fn task_bindings_snapshot() -> HashMap { + CURRENT_SESSION_TASKS + .try_with(|slot| slot.borrow().clone()) + .unwrap_or_default() +} + +fn current_state() -> Arc> { + let key = type_key::(); + let thread_binding = CURRENT_SESSION_THREADS.with(|slot| slot.borrow().get(&key).cloned()); + let task_binding = CURRENT_SESSION_TASKS + .try_with(|slot| slot.borrow().get(&key).cloned()) + .ok() + .flatten(); + + match (thread_binding, task_binding) { + (Some(thread), Some(task)) => { + if thread.order > task.order { + downcast_state::(thread.state) + } else { + downcast_state::(task.state) + } + } + (Some(thread), None) => downcast_state::(thread.state), + (None, Some(task)) => downcast_state::(task.state), + (None, None) => default_state::(), + } +} + +pub fn with_runtime(f: impl FnOnce(&Tx::Runtime) -> R) -> R { + let state = current_state::(); + f(&state.runtime) +} + +pub fn with_pat_recorder( + f: impl FnOnce(&Tx::PatRecorder) -> R, +) -> R { + let state = current_state::(); + let pat_recorder = state.pat_recorder.lock().unwrap(); + f(&pat_recorder) +} + +pub struct Session { + state: Arc>, +} + +impl Clone for Session { + fn clone(&self) -> Self { + Self { + state: Arc::clone(&self.state), + } + } +} + +impl Session { + pub fn new() -> Self { + Self { + state: Arc::new(SessionState::::new()), + } + } + + pub fn default() -> Self { + Self { + state: default_state::(), + } + } + + pub fn run(&self, f: impl FnOnce() -> R) -> R { + let key = type_key::(); + CURRENT_SESSION_THREADS.with(|slot| { + let previous = slot + .borrow_mut() + .insert(key, ErasedSessionBinding::new::(Arc::clone(&self.state))); + let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(f)); + let mut bindings = slot.borrow_mut(); + match previous { + Some(previous) => { + bindings.insert(key, previous); + } + None => { + bindings.remove(&key); + } + } + match result { + Ok(value) => value, + Err(payload) => std::panic::resume_unwind(payload), + } + }) + } + + pub async fn run_async(&self, fut: impl Future) -> R { + let mut bindings = task_bindings_snapshot(); + for (key, binding) in CURRENT_SESSION_THREADS.with(|slot| slot.borrow().clone()) { + match bindings.get(&key) { + Some(existing) if existing.order > binding.order => {} + _ => { + bindings.insert(key, binding); + } + } + } + bindings.insert( + type_key::(), + ErasedSessionBinding::new::(Arc::clone(&self.state)), + ); + CURRENT_SESSION_TASKS.scope(RefCell::new(bindings), fut).await + } + + pub fn spawn( + &self, + f: impl FnOnce() -> R + Send + 'static, + ) -> std::thread::JoinHandle { + let session = Session { + state: Arc::clone(&self.state), + }; + std::thread::spawn(move || session.run(f)) + } + + pub fn spawn_async( + &self, + fut: impl Future + Send + 'static, + ) -> tokio::task::JoinHandle { + let mut bindings = task_bindings_snapshot(); + for (key, binding) in CURRENT_SESSION_THREADS.with(|slot| slot.borrow().clone()) { + match bindings.get(&key) { + Some(existing) if existing.order > binding.order => {} + _ => { + bindings.insert(key, binding); + } + } + } + bindings.insert( + type_key::(), + ErasedSessionBinding::new::(Arc::clone(&self.state)), + ); + tokio::spawn(CURRENT_SESSION_TASKS.scope(RefCell::new(bindings), fut)) + } + + pub fn get_or_register_ruleset( + &self, + key: &'static str, + build: impl FnOnce() -> RuleSetId, + ) -> RuleSetId { + get_or_register_ruleset_state::(&self.state, key, build) + } +} + +fn get_or_register_ruleset_state( + state: &Arc>, + key: &'static str, + build: impl FnOnce() -> RuleSetId, +) -> RuleSetId { + let current_thread = std::thread::current().id(); + + loop { + let mut rulesets = state.rulesets.lock().unwrap(); + match rulesets.get(key).copied() { + Some(RulesetRegistration::Ready(ruleset)) => return ruleset, + Some(RulesetRegistration::Building { owner }) => { + if owner == current_thread { + drop(rulesets); + panic!("reentrant ruleset registration for key `{key}` is not supported"); + } + let guard = state.rulesets_cv.wait(rulesets).unwrap(); + drop(guard); + } + None => { + rulesets.insert( + key, + RulesetRegistration::Building { + owner: current_thread, + }, + ); + drop(rulesets); + + let build_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(build)); + + let mut rulesets = state.rulesets.lock().unwrap(); + match build_result { + Ok(ruleset) => { + rulesets.insert(key, RulesetRegistration::Ready(ruleset)); + state.rulesets_cv.notify_all(); + return ruleset; + } + Err(payload) => { + rulesets.remove(key); + state.rulesets_cv.notify_all(); + std::panic::resume_unwind(payload); + } + } + } + } + } +} + +pub fn get_or_register_ruleset( + key: &'static str, + build: impl FnOnce() -> RuleSetId, +) -> RuleSetId { + let state = current_state::(); + get_or_register_ruleset_state::(&state, key, build) +} + +pub fn reset_for_bench() { + let state = current_state::(); + Tx::reset_runtime_for_bench(&state.runtime); + *state.pat_recorder.lock().unwrap() = Tx::new_pat_recorder(); + let mut rulesets = state.rulesets.lock().unwrap(); + rulesets.clear(); + state.rulesets_cv.notify_all(); +} + +pub fn egraph() -> Arc> { + with_runtime::(Tx::runtime_egraph) +} + +pub trait SessionAwareTxMarker: Sized + 'static { + type Runtime: Tx + + Rx + + VersionCtl + + TxCommit + + NodeOwner + + NodeDropper + + NodeSetter + + ToDot + + RuleRunner + + Send + + Sync + + 'static; + type PatRecorder: PatRec::MetaTy> + + NodeOwner + + NodeDropper + + NodeSetter + + Tx + + Send + + Sync + + 'static; + type PatRecMarker: SessionAwarePatRecMarker + PatRecSgl; + + fn new_runtime() -> Self::Runtime; + fn new_pat_recorder() -> Self::PatRecorder; + fn runtime_egraph(runtime: &Self::Runtime) -> Arc>; + fn reset_runtime_for_bench(runtime: &Self::Runtime); +} + +pub trait SessionAwarePatRecMarker: Sized + 'static { + type TxMarker: SessionAwareTxMarker; + type MetaTy: crate::wrap::Meta; +} + +pub trait SessionAwareTxSgl: SessionAwareTxMarker { + fn new_session() -> Session { + Session::new() + } + + fn default_session() -> Session { + Session::default() + } +} + +impl SessionAwareTxSgl for T {} + +pub struct SessionTxFacade(PhantomData); + +impl SessionTxFacade { + pub const fn new() -> Self { + Self(PhantomData) + } +} + +impl NodeOwner for SessionTxFacade { + type OwnerSpecDataInNode = + ::OwnerSpecDataInNode; +} + +impl NodeDropper for SessionTxFacade { + fn on_drop(&self, dropped: &mut (impl EgglogNode + 'static)) { + with_runtime::(|runtime| runtime.on_drop(dropped)); + } +} + +impl NodeSetter for SessionTxFacade { + fn on_set(&self, node: &mut (impl EgglogNode + 'static)) { + with_runtime::(|runtime| runtime.on_set(node)); + } +} + +impl Tx for SessionTxFacade { + fn send(&self, sended: TxCommand) { + with_runtime::(|runtime| runtime.send(sended)); + } + + fn on_new(&self, node: &(impl EgglogNode + 'static)) { + with_runtime::(|runtime| runtime.on_new(node)); + } + + fn on_func_set<'a, F: EgglogFunc>( + &self, + input: ::Ref<'a>, + output: ::Ref<'a>, + ) { + with_runtime::(|runtime| runtime.on_func_set::(input, output)); + } + + fn on_relation_insert<'a, R: EgglogRelation>( + &self, + input: ::Ref<'a>, + ) { + with_runtime::(|runtime| runtime.on_relation_insert::(input)); + } + + fn on_union(&self, node1: &(impl EgglogNode + 'static), node2: &(impl EgglogNode + 'static)) { + with_runtime::(|runtime| runtime.on_union(node1, node2)); + } + + fn canonical_raw(&self, node1: &(impl EgglogNode + 'static)) -> egglog::Value { + with_runtime::(|runtime| runtime.canonical_raw(node1)) + } +} + +impl Rx for SessionTxFacade { + fn on_func_get<'a, F: EgglogFunc>( + &self, + input: ::Ref<'a>, + ) -> F::Output { + with_runtime::(|runtime| runtime.on_func_get::(input)) + } + + fn on_funcs_get<'a, 'b, F: EgglogFunc>( + &self, + max_size: Option, + ) -> Vec<( + ::Ref<'b>, + ::Ref<'b>, + )> { + with_runtime::(|runtime| runtime.on_funcs_get::(max_size)) + } + + fn on_pull_sym(&self, sym: Sym) -> crate::wrap::SymLit { + with_runtime::(|runtime| runtime.on_pull_sym::(sym)) + } + + fn on_pull_value(&self, value: Value) -> crate::wrap::SymLit { + with_runtime::(|runtime| runtime.on_pull_value::(value)) + } +} + +impl VersionCtl for SessionTxFacade { + fn locate_latest(&self, node: Sym) -> Sym { + with_runtime::(|runtime| runtime.locate_latest(node)) + } + fn locate_next(&self, node: Sym) -> Sym { + with_runtime::(|runtime| runtime.locate_next(node)) + } + fn locate_prev(&self, node: Sym) -> Sym { + with_runtime::(|runtime| runtime.locate_prev(node)) + } + fn set_latest(&self, node: &mut Sym) { + with_runtime::(|runtime| runtime.set_latest(node)); + } + fn set_next(&self, node: &mut Sym) { + with_runtime::(|runtime| runtime.set_next(node)); + } + fn set_prev(&self, node: &mut Sym) { + with_runtime::(|runtime| runtime.set_prev(node)); + } +} + +impl TxCommit for SessionTxFacade { + fn on_stage(&self, node: &T) { + with_runtime::(|runtime| runtime.on_stage(node)); + } + + fn on_commit_op_hook(&self, node: &T, hook: Option>) { + with_runtime::(|runtime| runtime.on_commit_op_hook(node, hook)); + } +} + +impl RuleRunner for SessionTxFacade +where + TxMarker: SessionAwareTxMarker, + TxMarker::PatRecMarker: PatRecSgl, +{ + fn add_rule>( + &self, + rule_name: &str, + rule_set: RuleSetId, + pat: impl Fn() -> P, + action: impl Fn(&crate::wrap::PRRuleCtx, &P::Valued) + + Send + + Sync + + 'static + + Clone, + ctx_hook: Option>, + ) { + with_runtime::(|runtime| { + runtime.add_rule::

(rule_name, rule_set, pat, action, ctx_hook) + }); + } + + fn new_ruleset(&self, rule_set: &'static str) -> RuleSetId { + with_runtime::(|runtime| runtime.new_ruleset(rule_set)) + } + + fn run_ruleset(&self, rule_set_id: RuleSetId, run_config: RunConfig) -> RunReport { + with_runtime::(|runtime| runtime.run_ruleset(rule_set_id, run_config)) + } + + fn value(&self, node: &T) -> Value { + with_runtime::(|runtime| runtime.value(node)) + } +} + +impl ToDot for SessionTxFacade { + fn egraph_to_dot(&self, path: impl AsRef) { + with_runtime::(|runtime| runtime.egraph_to_dot(path)); + } + + fn wag_to_dot(&self, path: impl AsRef) { + with_runtime::(|runtime| runtime.wag_to_dot(path)); + } + + fn wag_to_petgraph(&self) -> crate::wrap::SerializedPetGraph { + with_runtime::(|runtime| runtime.wag_to_petgraph()) + } + + fn table_view(&self) { + with_runtime::(|runtime| runtime.table_view()); + } +} + +pub struct SessionPatRecFacade(PhantomData); + +impl SessionPatRecFacade { + pub const fn new() -> Self { + Self(PhantomData) + } +} + +impl NodeOwner for SessionPatRecFacade { + type OwnerSpecDataInNode = + <::PatRecorder as NodeOwner>::OwnerSpecDataInNode; +} + +impl NodeDropper for SessionPatRecFacade { + fn on_drop(&self, dropped: &mut (impl EgglogNode + 'static)) { + with_pat_recorder::(|pat_rec| pat_rec.on_drop(dropped)); + } +} + +impl NodeSetter for SessionPatRecFacade { + fn on_set(&self, node: &mut (impl EgglogNode + 'static)) { + with_pat_recorder::(|pat_rec| pat_rec.on_set(node)); + } +} + +impl Tx for SessionPatRecFacade { + fn send(&self, sended: TxCommand) { + with_pat_recorder::(|pat_rec| pat_rec.send(sended)); + } + + fn on_new(&self, node: &(impl EgglogNode + 'static)) { + with_pat_recorder::(|pat_rec| pat_rec.on_new(node)); + } + + fn on_func_set<'a, F: EgglogFunc>( + &self, + input: ::Ref<'a>, + output: ::Ref<'a>, + ) { + with_pat_recorder::(|pat_rec| pat_rec.on_func_set::(input, output)); + } + + fn on_union(&self, node1: &(impl EgglogNode + 'static), node2: &(impl EgglogNode + 'static)) { + with_pat_recorder::(|pat_rec| pat_rec.on_union(node1, node2)); + } + + fn canonical_raw(&self, node1: &(impl EgglogNode + 'static)) -> egglog::Value { + with_pat_recorder::(|pat_rec| pat_rec.canonical_raw(node1)) + } +} + +impl PatRec for SessionPatRecFacade { + type MetaTy = <::PatRecorder as PatRec>::MetaTy; + + fn on_new_query_leaf(&self, node: &(impl EgglogNode + 'static)) { + with_pat_recorder::(|pat_rec| pat_rec.on_new_query_leaf(node)); + } + + fn on_new_constraint(&self, constraint: impl crate::wrap::IntoConstraintFact) { + with_pat_recorder::(|pat_rec| pat_rec.on_new_constraint(constraint)); + } + + fn on_new_table_fact(&self, query_table: TableName, vars: Vec<(VarName, SortName)>) { + with_pat_recorder::(|pat_rec| pat_rec.on_new_table_fact(query_table, vars)); + } + + fn on_new_relation_fact(&self, query_table: TableName, vars: Vec<(VarName, SortName)>) { + with_pat_recorder::(|pat_rec| pat_rec.on_new_relation_fact(query_table, vars)); + } + + fn on_record_start(&self) { + with_pat_recorder::(|pat_rec| pat_rec.on_record_start()); + } + + fn on_record_end(&self, pat_vars: &impl PatVars) -> PatId { + with_pat_recorder::(|pat_rec| pat_rec.on_record_end(pat_vars)) + } + + fn pat2fact_builder(&self, pat_id: PatId) -> FactsBuilder { + with_pat_recorder::(|pat_rec| pat_rec.pat2fact_builder(pat_id)) + } + + fn on_ctx_insert( + &self, + inputs: Vec>, + output: ( + crate::prelude::slotted::FuncName, + egglog::Value, + Option, + ), + ) { + with_pat_recorder::(|pat_rec| { + pat_rec.on_ctx_insert::(inputs, output) + }); + } + + fn on_ctx_union( + &self, + combo1: crate::prelude::slotted::FuncValueMeta, + combo2: crate::prelude::slotted::FuncValueMeta, + ) { + with_pat_recorder::(|pat_rec| pat_rec.on_ctx_union(combo1, combo2)); + } + + fn flush_pending(&self, egraph: &EGraph) -> bool { + with_pat_recorder::(|pat_rec| pat_rec.flush_pending(egraph)) + } +} diff --git a/src/prelude.rs b/src/prelude.rs index 77468b5..8db8713 100644 --- a/src/prelude.rs +++ b/src/prelude.rs @@ -19,6 +19,7 @@ pub use crate::artifact::{ read_binary_artifact_header_from_file, restore_persisted_snapshot_v1, }; pub use crate::instances::pat_rec::*; +pub use crate::instances::pseudo_singleton::{Session, SessionAwareTxSgl}; pub use crate::instances::tx::*; pub use crate::instances::tx_minimal::*; pub use crate::instances::tx_rx_vt::*; @@ -40,8 +41,8 @@ pub use crate::wrap::sorts::set::SetContainer; pub use crate::wrap::sorts::vec::VecContainer; pub use crate::wrap::{ AsHandle, BaseVar, Commit, EgglogNode, ExtractBackend, ExtractNodeSgl, ExtractSgl, FromBase, - Insertable, LocateVersion, PEq, PatRecSgl, QuerySlot, RenderedTemplateField, RuleRunnerSgl, - RuleSetId, RunConfig, RustsatExtractConfig, RxSgl, SingletonGetter, SlotVarID, + Insertable, LocateVersion, NonPatRecSgl, PEq, PatRecSgl, QuerySlot, RenderedTemplateField, + RuleRunnerSgl, RuleSetId, RunConfig, RustsatExtractConfig, RxSgl, SingletonGetter, SlotVarID, SlottedPatRecSgl, ToDot, ToDotSgl, TxCommit, TxCommitSgl, TxSgl, Value, render_template_with_precedence, render_variant_display, render_variant_typst, }; diff --git a/src/test.rs b/src/test.rs index 0431550..2f70639 100644 --- a/src/test.rs +++ b/src/test.rs @@ -577,11 +577,13 @@ mod tests { #[test] fn serialized_artifact_matches_current_schema() { let artifact = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_serialized_eggplant_artifact(&egraph, egglog::SerializeConfig::default()).unwrap() }; let report = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); compare_artifact_to_current(&artifact, &egraph) }; @@ -592,7 +594,8 @@ mod tests { #[test] fn changing_dsl_metadata_is_metadata_only_change() { let mut artifact = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_serialized_eggplant_artifact(&egraph, egglog::SerializeConfig::default()).unwrap() }; @@ -619,7 +622,8 @@ mod tests { ); let report = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); compare_artifact_to_current(&artifact, &egraph) }; assert!(report.typed_continuation_allowed); @@ -635,7 +639,8 @@ mod tests { #[test] fn changing_dsl_field_kind_blocks_typed_continuation() { let mut artifact = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_serialized_eggplant_artifact(&egraph, egglog::SerializeConfig::default()).unwrap() }; @@ -648,7 +653,8 @@ mod tests { variant.fields[0].kind = ArtifactDslFieldKind::Container; let report = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); compare_artifact_to_current(&artifact, &egraph) }; assert!(!report.typed_continuation_allowed); @@ -683,7 +689,8 @@ mod tests { #[test] fn serialized_artifact_exposes_variant_precedence_and_typst_templates_without_expansion() { let artifact = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_serialized_eggplant_artifact(&egraph, egglog::SerializeConfig::default()).unwrap() }; let add = artifact @@ -706,7 +713,8 @@ mod tests { #[test] fn serialized_artifact_json_keeps_variant_precedence_and_typst_template_fields() { let artifact = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_serialized_eggplant_artifact(&egraph, egglog::SerializeConfig::default()).unwrap() }; let json = serde_json::to_value(&artifact).unwrap(); @@ -785,7 +793,8 @@ mod tests { #[test] fn serialized_artifact_binary_round_trip_preserves_payload() { let artifact = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_serialized_eggplant_artifact(&egraph, egglog::SerializeConfig::default()).unwrap() }; @@ -798,7 +807,8 @@ mod tests { #[test] fn serialized_artifact_binary_header_exposes_contract_fields() { let artifact = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_serialized_eggplant_artifact(&egraph, egglog::SerializeConfig::default()).unwrap() }; @@ -828,7 +838,8 @@ mod tests { #[test] fn serialized_artifact_binary_file_io_round_trip_preserves_payload() { let artifact = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_serialized_eggplant_artifact(&egraph, egglog::SerializeConfig::default()).unwrap() }; let path = temp_binary_path("serialized_artifact_round_trip"); @@ -847,13 +858,14 @@ mod tests { #[test] fn persisted_snapshot_binary_round_trip_preserves_payload() { - MyTx::sgl().reset_for_bench(); + MyTx::reset_for_bench(); let root = Root::::new(&Const::new(17)); root.commit(); RelEdge::::insert(4, 5); let snapshot = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v2_eqclass(&egraph, egglog::SerializeConfig::default()) }; @@ -865,12 +877,13 @@ mod tests { #[test] fn persisted_snapshot_binary_header_exposes_contract_fields() { - MyTx::sgl().reset_for_bench(); + MyTx::reset_for_bench(); let root = Root::::new(&Const::new(19)); root.commit(); let snapshot = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v2_eqclass(&egraph, egglog::SerializeConfig::default()) }; @@ -896,12 +909,13 @@ mod tests { #[test] fn persisted_snapshot_binary_file_io_round_trip_preserves_payload() { - MyTx::sgl().reset_for_bench(); + MyTx::reset_for_bench(); let root = Root::::new(&Const::new(29)); root.commit(); let snapshot = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) }; let path = temp_binary_path("persisted_snapshot_round_trip"); @@ -920,12 +934,13 @@ mod tests { #[test] fn binary_codec_rejects_payload_kind_mismatch() { - MyTx::sgl().reset_for_bench(); + MyTx::reset_for_bench(); let root = Root::::new(&Const::new(23)); root.commit(); let snapshot = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) }; let bytes = snapshot.to_binary_vec().unwrap(); @@ -942,12 +957,13 @@ mod tests { #[test] fn binary_file_io_rejects_payload_kind_mismatch() { - MyTx::sgl().reset_for_bench(); + MyTx::reset_for_bench(); let root = Root::::new(&Const::new(31)); root.commit(); let snapshot = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) }; let path = temp_binary_path("binary_kind_mismatch"); @@ -968,13 +984,15 @@ mod tests { #[test] fn artifact_format_version_mismatch_blocks_typed_continuation() { let mut artifact = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_serialized_eggplant_artifact(&egraph, egglog::SerializeConfig::default()).unwrap() }; artifact.format_version += 1; let report = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); compare_artifact_to_current(&artifact, &egraph) }; @@ -995,7 +1013,8 @@ mod tests { root_b.commit(); let snapshot = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) }; @@ -1035,7 +1054,8 @@ mod tests { root.commit(); let snapshot = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) }; @@ -1064,7 +1084,7 @@ mod tests { #[test] fn persisted_snapshot_v1_restore_replays_constructor_rows() { - MyTx::sgl().reset_for_bench(); + MyTx::reset_for_bench(); let root_a = Root::::new(&Const::new(7)); let root_b = Root::::new(&Const::new(9)); @@ -1072,17 +1092,20 @@ mod tests { root_b.commit(); let before = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) }; - MyTx::sgl().reset_for_bench(); + MyTx::reset_for_bench(); let report = { - let mut egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let mut egraph = egraph_handle.lock().unwrap(); restore_persisted_snapshot_v1(&mut egraph, &before).unwrap() }; let after = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) }; @@ -1109,23 +1132,26 @@ mod tests { #[test] fn persisted_snapshot_v1_restore_replays_relation_facts() { tx_rx_vt_pr!(RelRestoreTx, RelRestorePatRec); - RelRestoreTx::sgl().reset_for_bench(); + RelRestoreTx::reset_for_bench(); RelEdge::::insert(1, 2); RelEdge::::insert(2, 3); let before = { - let egraph = RelRestoreTx::sgl().egraph.lock().unwrap(); + let egraph_handle = RelRestoreTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) }; - RelRestoreTx::sgl().reset_for_bench(); + RelRestoreTx::reset_for_bench(); let report = { - let mut egraph = RelRestoreTx::sgl().egraph.lock().unwrap(); + let egraph_handle = RelRestoreTx::egraph(); + let mut egraph = egraph_handle.lock().unwrap(); restore_persisted_snapshot_v1(&mut egraph, &before).unwrap() }; let after = { - let egraph = RelRestoreTx::sgl().egraph.lock().unwrap(); + let egraph_handle = RelRestoreTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) }; @@ -1165,12 +1191,13 @@ mod tests { #[test] fn persisted_snapshot_v1_classifies_eggplant_native_relations_as_facts() { tx_rx_vt_pr!(RelPolicyTx, RelPolicyPatRec); - RelPolicyTx::sgl().reset_for_bench(); + RelPolicyTx::reset_for_bench(); RelEdge::::insert(7, 8); let snapshot = { - let egraph = RelPolicyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = RelPolicyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) }; @@ -1386,10 +1413,11 @@ mod tests { ); tx_rx_vt_pr!(PersistedMetaTx, PersistedMetaPatRec); - PersistedMetaTx::sgl().reset_for_bench(); + PersistedMetaTx::reset_for_bench(); RelEdge::::insert(1, 2); let relation_snapshot = { - let egraph = PersistedMetaTx::sgl().egraph.lock().unwrap(); + let egraph_handle = PersistedMetaTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) }; let relation_decl = relation_snapshot @@ -1507,10 +1535,11 @@ mod tests { ); tx_rx_vt_pr!(PersistedMetaJsonTx, PersistedMetaJsonPatRec); - PersistedMetaJsonTx::sgl().reset_for_bench(); + PersistedMetaJsonTx::reset_for_bench(); RelEdge::::insert(1, 2); let relation_snapshot = { - let egraph = PersistedMetaJsonTx::sgl().egraph.lock().unwrap(); + let egraph_handle = PersistedMetaJsonTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) }; let relation_json = serde_json::to_value(&relation_snapshot).unwrap(); @@ -1617,12 +1646,13 @@ mod tests { #[test] fn persisted_snapshot_v1_restore_rejects_non_fresh_target() { - MyTx::sgl().reset_for_bench(); + MyTx::reset_for_bench(); let root = Root::::new(&Const::new(7)); root.commit(); let snapshot = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) }; @@ -1646,7 +1676,7 @@ mod tests { #[test] fn persisted_snapshot_v1_persists_ruleset_name_provenance_only() { - MyTx::sgl().reset_for_bench(); + MyTx::reset_for_bench(); let ruleset = MyTx::new_ruleset("persisted_snapshot_ruleset_name"); MyTx::add_rule( "persisted_snapshot_ruleset_name_rule", @@ -1663,7 +1693,8 @@ mod tests { ); let snapshot = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) }; @@ -1692,7 +1723,7 @@ mod tests { #[test] fn persisted_snapshot_v1_restore_ignores_ruleset_name_provenance() { - MyTx::sgl().reset_for_bench(); + MyTx::reset_for_bench(); let ruleset = MyTx::new_ruleset("persisted_snapshot_restore_ignores_ruleset_name"); MyTx::add_rule( "persisted_snapshot_restore_ignores_ruleset_name_rule", @@ -1711,13 +1742,15 @@ mod tests { root.commit(); let snapshot = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) }; - MyTx::sgl().reset_for_bench(); + MyTx::reset_for_bench(); let report = { - let mut egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let mut egraph = egraph_handle.lock().unwrap(); restore_persisted_snapshot_v1(&mut egraph, &snapshot).unwrap() }; @@ -1730,12 +1763,13 @@ mod tests { #[test] fn persisted_snapshot_v1_captures_source_schema_alignment_header() { - MyTx::sgl().reset_for_bench(); + MyTx::reset_for_bench(); let root = Root::::new(&Const::new(13)); root.commit(); let (snapshot, current_engine_fingerprint) = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); ( build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()), engine_schema_fingerprint(&crate::artifact::current_engine_schema_manifest( @@ -1767,12 +1801,13 @@ mod tests { #[test] fn persisted_snapshot_v1_alignment_report_allows_metadata_only_drift() { - MyTx::sgl().reset_for_bench(); + MyTx::reset_for_bench(); let root = Root::::new(&Const::new(21)); root.commit(); let mut snapshot = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) }; snapshot @@ -1782,7 +1817,8 @@ mod tests { .dsl_metadata_fingerprint = "metadata-mismatch".to_string(); let report = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); compare_persisted_snapshot_to_current(&snapshot, &egraph) }; @@ -1797,12 +1833,13 @@ mod tests { #[test] fn persisted_snapshot_v1_restore_rejects_runtime_alignment_mismatch() { - MyTx::sgl().reset_for_bench(); + MyTx::reset_for_bench(); let root = Root::::new(&Const::new(34)); root.commit(); let mut snapshot = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) }; snapshot @@ -1811,9 +1848,10 @@ mod tests { .unwrap() .dsl_runtime_fingerprint = "runtime-mismatch".to_string(); - MyTx::sgl().reset_for_bench(); + MyTx::reset_for_bench(); let err = { - let mut egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let mut egraph = egraph_handle.lock().unwrap(); restore_persisted_snapshot_v1(&mut egraph, &snapshot).unwrap_err() }; @@ -2176,19 +2214,21 @@ mod tests { #[test] fn persisted_snapshot_v1_restore_rejects_missing_source_schema_header() { - MyTx::sgl().reset_for_bench(); + MyTx::reset_for_bench(); let root = Root::::new(&Const::new(55)); root.commit(); let mut snapshot = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) }; snapshot.source_schema = None; - MyTx::sgl().reset_for_bench(); + MyTx::reset_for_bench(); let err = { - let mut egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let mut egraph = egraph_handle.lock().unwrap(); restore_persisted_snapshot_v1(&mut egraph, &snapshot).unwrap_err() }; @@ -2201,12 +2241,13 @@ mod tests { #[test] fn persisted_snapshot_v2_eqclass_uses_distinct_profile_and_version() { - MyTx::sgl().reset_for_bench(); + MyTx::reset_for_bench(); let root = Root::::new(&Const::new(3)); root.commit(); let snapshot = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v2_eqclass(&egraph, egglog::SerializeConfig::default()) }; @@ -2252,19 +2293,21 @@ mod tests { #[test] fn persisted_snapshot_v2_restore_ignores_eqclass_payload_for_semantic_replay() { - MyTx::sgl().reset_for_bench(); + MyTx::reset_for_bench(); let root = Root::::new(&Const::new(11)); root.commit(); RelEdge::::insert(1, 2); let snapshot = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v2_eqclass(&egraph, egglog::SerializeConfig::default()) }; - MyTx::sgl().reset_for_bench(); + MyTx::reset_for_bench(); let report = { - let mut egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let mut egraph = egraph_handle.lock().unwrap(); restore_persisted_snapshot_v1(&mut egraph, &snapshot).unwrap() }; @@ -2277,19 +2320,21 @@ mod tests { #[test] fn persisted_snapshot_v2_restore_rejects_missing_eqclass_payload() { - MyTx::sgl().reset_for_bench(); + MyTx::reset_for_bench(); let root = Root::::new(&Const::new(12)); root.commit(); let mut snapshot = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v2_eqclass(&egraph, egglog::SerializeConfig::default()) }; snapshot.eq_class_payload = None; - MyTx::sgl().reset_for_bench(); + MyTx::reset_for_bench(); let err = { - let mut egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let mut egraph = egraph_handle.lock().unwrap(); restore_persisted_snapshot_v1(&mut egraph, &snapshot).unwrap_err() }; @@ -2348,7 +2393,8 @@ mod tests { #[test] fn serialized_artifact_captures_function_flags() { let artifact = { - let egraph = MyTx::sgl().egraph.lock().unwrap(); + let egraph_handle = MyTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_serialized_eggplant_artifact(&egraph, egglog::SerializeConfig::default()).unwrap() }; let func = artifact @@ -3591,7 +3637,7 @@ mod proofs_api_tests { impl eggplant::wrap::NonPatRecSgl for MyTxProof { fn egraph() -> std::sync::Arc> { - Self::sgl().egraph.clone() + ::egraph() } } @@ -3688,7 +3734,8 @@ mod proofs_api_tests { // 3) Regression: proof export should work for non-canonical values too (class-id/canon-rep keying). let (rep, non_rep) = { - let egraph = MyTxProof::sgl().egraph.lock().unwrap(); + let egraph_handle = ::egraph(); + let egraph = egraph_handle.lock().unwrap(); let sort = egraph.get_sort_by_name("ProofExpr").unwrap().clone(); let rep = egraph.get_canonical_value(mul_value, &sort); let non_rep = if mul_value != rep { diff --git a/src/wrap/mod.rs b/src/wrap/mod.rs index 5c9bdfc..b5e2ca3 100644 --- a/src/wrap/mod.rs +++ b/src/wrap/mod.rs @@ -1,3 +1,4 @@ +pub use crate::egglog; pub use derive_more; mod func; pub use func::*; diff --git a/tests/indexed_pat_decode.rs b/tests/indexed_pat_decode.rs index bbaf317..edc1fb9 100644 --- a/tests/indexed_pat_decode.rs +++ b/tests/indexed_pat_decode.rs @@ -33,7 +33,7 @@ fn serialized_user_node_count() -> usize { #[test] fn indexed_pat_decode_preserves_node_growth_and_canonical_result() { let _ = env_logger::builder().is_test(true).try_init(); - MyTxIndexedDecode::sgl().reset_for_bench(); + MyTxIndexedDecode::reset_for_bench(); let lhs = IxConst::::new(1); let rhs = IxConst::::new(2); diff --git a/tests/persisted_snapshot_constant_prop_continuation.rs b/tests/persisted_snapshot_constant_prop_continuation.rs index 826ab22..c5699b1 100644 --- a/tests/persisted_snapshot_constant_prop_continuation.rs +++ b/tests/persisted_snapshot_constant_prop_continuation.rs @@ -66,7 +66,8 @@ fn snapshot_path() -> PathBuf { fn dump_snapshot_to_disk(path: &PathBuf) { let snapshot = { - let egraph = ContTx::sgl().egraph.lock().unwrap(); + let egraph_handle = ContTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) }; fs::write(path, serde_json::to_string_pretty(&snapshot).unwrap()).unwrap(); @@ -105,7 +106,7 @@ fn canonical_eq(lhs: &Expr, rhs_const: i64) -> bool { fn persisted_snapshot_constant_prop_continues_after_restore() { let _guard = test_guard(); - ContTx::sgl().reset_for_bench(); + ContTx::reset_for_bench(); let ruleset = register_constant_prop_rules(); let mul: Expr = Mul::new(&Const::new(3), &Const::new(2)); @@ -126,15 +127,17 @@ fn persisted_snapshot_constant_prop_continues_after_restore() { let path = snapshot_path(); dump_snapshot_to_disk(&path); - ContTx::sgl().reset_for_bench(); + ContTx::reset_for_bench(); let ruleset = register_constant_prop_rules(); let snapshot = load_snapshot_from_disk(&path); { - let mut egraph = ContTx::sgl().egraph.lock().unwrap(); + let egraph_handle = ContTx::egraph(); + let mut egraph = egraph_handle.lock().unwrap(); restore_persisted_snapshot_v1(&mut egraph, &snapshot).unwrap(); } let restored_snapshot = { - let egraph = ContTx::sgl().egraph.lock().unwrap(); + let egraph_handle = ContTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) }; assert!( diff --git a/tests/persisted_snapshot_corpus_validation.rs b/tests/persisted_snapshot_corpus_validation.rs index 2afe883..52bd8a6 100644 --- a/tests/persisted_snapshot_corpus_validation.rs +++ b/tests/persisted_snapshot_corpus_validation.rs @@ -48,20 +48,22 @@ tx_rx_vt_pr!(CorpusTx, CorpusPatRec); #[test] fn persisted_snapshot_corpus_common_path_round_trips() { - CorpusTx::sgl().reset_for_bench(); + CorpusTx::reset_for_bench(); let root = Root::::new(&Const::new(7)); root.commit(); CorpusEdge::::insert(1, 2); let snapshot = { - let egraph = CorpusTx::sgl().egraph.lock().unwrap(); + let egraph_handle = CorpusTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v1(&egraph, eggplant::egglog::SerializeConfig::default()) }; let summary = persisted_snapshot_capability_summary(&snapshot); - CorpusTx::sgl().reset_for_bench(); + CorpusTx::reset_for_bench(); let report = { - let mut egraph = CorpusTx::sgl().egraph.lock().unwrap(); + let egraph_handle = CorpusTx::egraph(); + let mut egraph = egraph_handle.lock().unwrap(); restore_persisted_snapshot_v1(&mut egraph, &snapshot).unwrap() }; diff --git a/tests/persisted_snapshot_fixture_stability.rs b/tests/persisted_snapshot_fixture_stability.rs index 45c3cba..09f8f74 100644 --- a/tests/persisted_snapshot_fixture_stability.rs +++ b/tests/persisted_snapshot_fixture_stability.rs @@ -116,13 +116,14 @@ fn normalize_snapshot_for_fixture(snapshot: &mut PersistedSnapshot) { } fn build_common_path_snapshot() -> PersistedSnapshot { - FixtureTx::sgl().reset_for_bench(); + FixtureTx::reset_for_bench(); let root_a = Root::::new(&Const::new(7)); let root_b = Root::::new(&Const::new(9)); root_a.commit(); root_b.commit(); FixtureEdge::::insert(1, 2); - let egraph = FixtureTx::sgl().egraph.lock().unwrap(); + let egraph_handle = FixtureTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v1(&egraph, eggplant::egglog::SerializeConfig::default()) } @@ -133,13 +134,14 @@ fn build_common_path_fixture_snapshot() -> PersistedSnapshot { } fn build_common_path_v2_eqclass_snapshot() -> PersistedSnapshot { - FixtureTx::sgl().reset_for_bench(); + FixtureTx::reset_for_bench(); let root_a = Root::::new(&Const::new(7)); let root_b = Root::::new(&Const::new(9)); root_a.commit(); root_b.commit(); FixtureEdge::::insert(1, 2); - let egraph = FixtureTx::sgl().egraph.lock().unwrap(); + let egraph_handle = FixtureTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v2_eqclass(&egraph, eggplant::egglog::SerializeConfig::default()) } @@ -419,13 +421,15 @@ fn persisted_snapshot_common_path_fixture_restore_is_compatible() { fixture.source_schema = current.source_schema.clone(); fixture.producer = current.producer.clone(); - FixtureTx::sgl().reset_for_bench(); + FixtureTx::reset_for_bench(); let report = { - let mut egraph = FixtureTx::sgl().egraph.lock().unwrap(); + let egraph_handle = FixtureTx::egraph(); + let mut egraph = egraph_handle.lock().unwrap(); restore_persisted_snapshot_v1(&mut egraph, &fixture).unwrap() }; let restored = { - let egraph = FixtureTx::sgl().egraph.lock().unwrap(); + let egraph_handle = FixtureTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v1(&egraph, eggplant::egglog::SerializeConfig::default()) }; @@ -482,13 +486,15 @@ fn persisted_snapshot_v2_common_path_fixture_restore_is_compatible() { fixture.source_schema = current.source_schema.clone(); fixture.producer = current.producer.clone(); - FixtureTx::sgl().reset_for_bench(); + FixtureTx::reset_for_bench(); let report = { - let mut egraph = FixtureTx::sgl().egraph.lock().unwrap(); + let egraph_handle = FixtureTx::egraph(); + let mut egraph = egraph_handle.lock().unwrap(); restore_persisted_snapshot_v1(&mut egraph, &fixture).unwrap() }; let restored = { - let egraph = FixtureTx::sgl().egraph.lock().unwrap(); + let egraph_handle = FixtureTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_persisted_snapshot_v1(&egraph, eggplant::egglog::SerializeConfig::default()) }; diff --git a/tests/pseudo_singleton_constant_prop.rs b/tests/pseudo_singleton_constant_prop.rs index 0444407..84ba5a3 100644 --- a/tests/pseudo_singleton_constant_prop.rs +++ b/tests/pseudo_singleton_constant_prop.rs @@ -30,3 +30,13 @@ fn pseudo_singleton_constant_prop_sync_run_can_override_outer_async_session() { fn pseudo_singleton_constant_prop_same_session_concurrent_registration_is_safe() { pseudo_singleton_constant_prop::same_session_concurrent_registration_is_safe(); } + +#[test] +fn pseudo_singleton_constant_prop_nested_ruleset_registration_is_safe() { + pseudo_singleton_constant_prop::nested_ruleset_registration_is_safe(); +} + +#[test] +fn pseudo_singleton_constant_prop_same_key_nested_registration_fails_fast() { + pseudo_singleton_constant_prop::nested_same_key_registration_panics_instead_of_deadlocking(); +} diff --git a/tests/rustsat_common_subexpr.rs b/tests/rustsat_common_subexpr.rs index e56c77d..9ea0ecc 100644 --- a/tests/rustsat_common_subexpr.rs +++ b/tests/rustsat_common_subexpr.rs @@ -12,7 +12,7 @@ tx_rx_vt_pr!(RustsatCseTx, RustsatCsePatRec); #[test] fn rustsat_backend_prefers_shared_subexpression_when_tree_cost_overcounts() { let _ = env_logger::builder().is_test(true).try_init(); - RustsatCseTx::sgl().reset_for_bench(); + RustsatCseTx::reset_for_bench(); let shared_leaf = CLeaf::::new(0); let shared_l1 = CInc::::new(&shared_leaf); diff --git a/tests/rustsat_optimize_expression.rs b/tests/rustsat_optimize_expression.rs index a3d8091..2490223 100644 --- a/tests/rustsat_optimize_expression.rs +++ b/tests/rustsat_optimize_expression.rs @@ -33,7 +33,7 @@ tx_rx_vt_pr!(RustsatCycleTx, RustsatCyclePatRec); #[test] fn rustsat_backend_optimizes_wrapper_expression_without_legacy_fallback() { let _ = env_logger::builder().is_test(true).try_init(); - RustsatDemoTx::sgl().reset_for_bench(); + RustsatDemoTx::reset_for_bench(); let leaf = Leaf::::new(7); let cheap = CheapWrap::::new(&leaf); @@ -85,7 +85,7 @@ fn rustsat_backend_optimizes_wrapper_expression_without_legacy_fallback() { #[test] fn rustsat_backend_keeps_acyclic_witness_in_cyclic_root_class() { let _ = env_logger::builder().is_test(true).try_init(); - RustsatCycleTx::sgl().reset_for_bench(); + RustsatCycleTx::reset_for_bench(); let leaf = CycleLeaf::::new(5); let wrap = CycleWrap::::new(&leaf); diff --git a/tests/serialized_artifact_fixture_stability.rs b/tests/serialized_artifact_fixture_stability.rs index 8c97a64..c389d81 100644 --- a/tests/serialized_artifact_fixture_stability.rs +++ b/tests/serialized_artifact_fixture_stability.rs @@ -50,13 +50,14 @@ fn binary_fixture_path(name: &str) -> PathBuf { } fn build_common_path_artifact() -> SerializedEggplantArtifact { - ArtifactFixtureTx::sgl().reset_for_bench(); + ArtifactFixtureTx::reset_for_bench(); let root_a = Root::::new(&Const::new(7)); let root_b = Root::::new(&Const::new(9)); root_a.commit(); root_b.commit(); ArtifactFixtureEdge::::insert(1, 2); - let egraph = ArtifactFixtureTx::sgl().egraph.lock().unwrap(); + let egraph_handle = ArtifactFixtureTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); build_serialized_eggplant_artifact(&egraph, eggplant::egglog::SerializeConfig::default()) .unwrap() } @@ -111,7 +112,8 @@ fn serialized_artifact_common_path_binary_fixture_is_continuation_compatible() { let fixture = read_binary_fixture("common_path"); let report = { - let egraph = ArtifactFixtureTx::sgl().egraph.lock().unwrap(); + let egraph_handle = ArtifactFixtureTx::egraph(); + let egraph = egraph_handle.lock().unwrap(); compare_artifact_to_current(&fixture, &egraph) }; diff --git a/tests/session_aware_tx.rs b/tests/session_aware_tx.rs new file mode 100644 index 0000000..11f254a --- /dev/null +++ b/tests/session_aware_tx.rs @@ -0,0 +1,252 @@ +use eggplant::{prelude::*, tx_rx_vt_pr}; +use std::sync::atomic::AtomicUsize; +use std::sync::atomic::Ordering; + +#[eggplant::dsl] +enum SessionExpr { + Const { num: i64 }, + Mul { l: SessionExpr, r: SessionExpr }, + Add { l: SessionExpr, r: SessionExpr }, +} + +tx_rx_vt_pr!(SessionTx, SessionPatRec); +tx_rx_vt_pr!(AltSessionTx, AltSessionPatRec); + +macro_rules! prop { + ($rule_name:expr, $ty:ident, $op:tt, $pat_name:ident, $ruleset:ident) => {{ + SessionTx::add_rule( + $rule_name, + $ruleset, + || { + let l = Const::query(); + let r = Const::query(); + let p = $ty::query(&l, &r); + #[eggplant::pat_vars_catch] + struct $pat_name { + l: Const, + r: Const, + p: $ty, + } + }, + |ctx, pat| { + let value = ctx.devalue(pat.l.num) $op ctx.devalue(pat.r.num); + let folded = ctx.insert_const(value); + ctx.union(pat.p, folded); + }, + ); + }}; +} + +fn register_rules() -> RuleSetId { + static NEXT_RULESET_ID: AtomicUsize = AtomicUsize::new(0); + let id = NEXT_RULESET_ID.fetch_add(1, Ordering::Relaxed); + let name: &'static str = Box::leak(format!("session_aware_constant_prop_{id}").into_boxed_str()); + let ruleset = SessionTx::new_ruleset(name); + prop!("AddPat", Add, +, AddPat, ruleset); + prop!("MulPat", Mul, *, MulPat, ruleset); + ruleset +} + +fn canonical_eq(lhs: &SessionExpr, rhs_const: i64) -> bool { + let rhs: SessionExpr = Const::new(rhs_const); + rhs.commit(); + SessionTx::canonical_raw(lhs) == SessionTx::canonical_raw(&rhs) +} + +fn current_has_const(needle: i64) -> bool { + let egraph = SessionTx::egraph(); + let egraph = egraph.lock().unwrap(); + let snapshot = build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()); + + let Some(const_decl) = snapshot + .schema + .constructor_decls + .iter() + .find(|decl| decl.name == "Const") + else { + return false; + }; + + snapshot.state.function_rows.iter().any(|row| { + row.op_id == const_decl.op_id + && matches!( + row.inputs.first(), + Some(PersistedSnapshotValue::Lit { value, .. }) if value.value == needle.to_string() + ) + }) +} + +fn fold_active_mul_add_expr(lhs: i64, rhs: i64, addend: i64) -> i64 { + let expr: SessionExpr = Add::new( + &Mul::new(&Const::new(lhs), &Const::new(rhs)), + &Const::new(addend), + ); + expr.commit(); + + let ruleset = register_rules(); + let _ = SessionTx::run_ruleset(ruleset, RunConfig::Sat); + + let expected = lhs * rhs + addend; + assert!(canonical_eq(&expr, expected)); + expected +} + +fn fold_active_mul_add_expr_alt(lhs: i64, rhs: i64, addend: i64) -> i64 { + let expr: SessionExpr = Add::new( + &Mul::new(&Const::new(lhs), &Const::new(rhs)), + &Const::new(addend), + ); + expr.commit(); + + let ruleset = { + static NEXT_RULESET_ID: AtomicUsize = AtomicUsize::new(0); + let id = NEXT_RULESET_ID.fetch_add(1, Ordering::Relaxed); + let name: &'static str = + Box::leak(format!("alt_session_aware_constant_prop_{id}").into_boxed_str()); + let ruleset = AltSessionTx::new_ruleset(name); + AltSessionTx::add_rule( + "AddPatAlt", + ruleset, + || { + let l = Const::query(); + let r = Const::query(); + let p = Add::query(&l, &r); + #[eggplant::pat_vars_catch] + struct AddPatAlt { + l: Const, + r: Const, + p: Add, + } + }, + |ctx, pat| { + let value = ctx.devalue(pat.l.num) + ctx.devalue(pat.r.num); + let folded = ctx.insert_const(value); + ctx.union(pat.p, folded); + }, + ); + AltSessionTx::add_rule( + "MulPatAlt", + ruleset, + || { + let l = Const::query(); + let r = Const::query(); + let p = Mul::query(&l, &r); + #[eggplant::pat_vars_catch] + struct MulPatAlt { + l: Const, + r: Const, + p: Mul, + } + }, + |ctx, pat| { + let value = ctx.devalue(pat.l.num) * ctx.devalue(pat.r.num); + let folded = ctx.insert_const(value); + ctx.union(pat.p, folded); + }, + ); + ruleset + }; + let _ = AltSessionTx::run_ruleset(ruleset, RunConfig::Sat); + + let expected = lhs * rhs + addend; + let rhs: SessionExpr = Const::new(expected); + rhs.commit(); + assert_eq!(AltSessionTx::canonical_raw(&expr), AltSessionTx::canonical_raw(&rhs)); + expected +} + +#[test] +fn default_generated_tx_uses_default_session_when_no_explicit_session_is_bound() { + assert_eq!(fold_active_mul_add_expr(3, 2, 4), 10); + assert!(current_has_const(10)); +} + +#[test] +fn generated_tx_can_isolate_two_explicit_sessions() { + let left = SessionTx::new_session(); + let right = SessionTx::new_session(); + + left.run(|| { + assert_eq!(fold_active_mul_add_expr(3, 2, 4), 10); + assert!(current_has_const(10)); + }); + + right.run(|| { + assert_eq!(fold_active_mul_add_expr(5, 5, 1), 26); + assert!(current_has_const(26)); + }); + + left.run(|| { + assert!(!current_has_const(26)); + }); + + right.run(|| { + assert!(!current_has_const(10)); + }); +} + +#[test] +fn generated_tx_can_route_explicit_async_sessions() { + let runtime = tokio::runtime::Builder::new_multi_thread() + .worker_threads(2) + .enable_all() + .build() + .unwrap(); + + runtime.block_on(async { + let left = SessionTx::new_session(); + let right = SessionTx::new_session(); + + let left_value = left + .run_async(async { + tokio::task::yield_now().await; + fold_active_mul_add_expr(3, 2, 4) + }) + .await; + assert_eq!(left_value, 10); + + let right_join = right.spawn_async(async { + tokio::task::yield_now().await; + fold_active_mul_add_expr(5, 5, 1) + }); + assert_eq!(right_join.await.unwrap(), 26); + }); +} + +#[test] +fn reset_for_bench_clears_session_ruleset_cache() { + let session = SessionTx::new_session(); + + session.run(|| { + assert_eq!(fold_active_mul_add_expr(3, 2, 4), 10); + SessionTx::reset_for_bench(); + assert_eq!(fold_active_mul_add_expr(2, 8, 1), 17); + }); +} + +#[test] +fn async_session_entry_preserves_other_thread_bound_tx_bindings() { + let runtime = tokio::runtime::Builder::new_multi_thread() + .worker_threads(2) + .enable_all() + .build() + .unwrap(); + + runtime.block_on(async { + let left = SessionTx::new_session(); + let right = AltSessionTx::new_session(); + + let seen_left_inside_right = left.run(|| { + assert_eq!(fold_active_mul_add_expr(3, 2, 4), 10); + right.spawn_async(async { + tokio::task::yield_now().await; + current_has_const(10) + }) + }); + assert!(seen_left_inside_right.await.unwrap()); + + right.run(|| { + assert_eq!(fold_active_mul_add_expr_alt(5, 5, 1), 26); + }); + }); +} diff --git a/tests/timestamp_match_filter.rs b/tests/timestamp_match_filter.rs index 0760a21..cce1020 100644 --- a/tests/timestamp_match_filter.rs +++ b/tests/timestamp_match_filter.rs @@ -18,7 +18,7 @@ tx_rx_vt_pr!(TsTx, TsPatRec); #[test] fn add_rule_timestamp_constraint_filters_old_matches() { let _ = env_logger::builder().is_test(true).try_init(); - TsTx::sgl().reset_for_bench(); + TsTx::reset_for_bench(); let old_leaf = Leaf::::new(1); old_leaf.commit(); @@ -83,7 +83,7 @@ tx_rx_vt_pr!(TsWindowTx, TsWindowPatRec); #[test] fn timestamp_constraint_uses_inclusive_lower_and_exclusive_upper_bounds() { let _ = env_logger::builder().is_test(true).try_init(); - TsWindowTx::sgl().reset_for_bench(); + TsWindowTx::reset_for_bench(); let oldest_leaf = WindowNode::::new(10); oldest_leaf.commit(); diff --git a/tests/typed_extract_cost_model.rs b/tests/typed_extract_cost_model.rs index 3cea39a..5d37030 100644 --- a/tests/typed_extract_cost_model.rs +++ b/tests/typed_extract_cost_model.rs @@ -52,7 +52,7 @@ impl eggplant::egglog::extract::CostModel::new(7); leaf.commit(); @@ -132,7 +132,7 @@ fn typed_extract_value_with_cost_model_uses_custom_cost_model() { #[test] fn typed_extract_backend_cost_model_matches_existing_cost_model_api() { let _ = env_logger::builder().is_test(true).try_init(); - MyTxExtractCost::sgl().reset_for_bench(); + MyTxExtractCost::reset_for_bench(); let leaf = Leaf::::new(7); leaf.commit(); @@ -179,7 +179,7 @@ fn typed_extract_backend_cost_model_matches_existing_cost_model_api() { #[test] fn typed_extract_backend_rustsat_uses_variant_costs_over_custom_cost_model_bias() { let _ = env_logger::builder().is_test(true).try_init(); - MyTxExtractCost::sgl().reset_for_bench(); + MyTxExtractCost::reset_for_bench(); let leaf = Leaf::::new(7); leaf.commit(); diff --git a/tests/typed_extract_dynamic_cost.rs b/tests/typed_extract_dynamic_cost.rs index 340a5fa..6472436 100644 --- a/tests/typed_extract_dynamic_cost.rs +++ b/tests/typed_extract_dynamic_cost.rs @@ -41,7 +41,7 @@ impl eggplant::egglog::extract::CostModel::new(9); expensive_leaf.commit(); From 2e4a3538da23758ffb76717df2536fc3ef9ed67b Mon Sep 17 00:00:00 2001 From: MilkBlock <2386925778@qq.com> Date: Thu, 23 Apr 2026 14:35:55 +0800 Subject: [PATCH 2/8] refactor(tx): hide pseudo-session naming Make session routing the default Tx story in user-facing names. This removes the pseudo-prefixed example and test filenames, deletes examples/support, renames the internal runtime module to session_runtime, and updates README copy to describe sessions as the default Tx behavior rather than a separate pseudo-singleton mode. Focused verification: - cargo test --test tx_sessions --test session_tx_constant_prop - cargo run --example constant_prop_sessions - cargo run --example constant_prop_sessions_async - subagent review: no findings --- README.md | 18 +- examples/constant_prop_pseudo_singleton.rs | 8 - .../constant_prop_pseudo_singleton_async.rs | 9 - examples/constant_prop_sessions.rs | 116 ++++++++++++ examples/constant_prop_sessions_async.rs | 141 +++++++++++++++ src/instances/mod.rs | 41 +++-- ...pseudo_singleton.rs => session_runtime.rs} | 90 +++++----- src/prelude.rs | 2 +- tests/pseudo_singleton_constant_prop.rs | 42 ----- .../session_tx_constant_prop.rs | 169 +++++++++--------- tests/{session_aware_tx.rs => tx_sessions.rs} | 0 11 files changed, 422 insertions(+), 214 deletions(-) delete mode 100644 examples/constant_prop_pseudo_singleton.rs delete mode 100644 examples/constant_prop_pseudo_singleton_async.rs create mode 100644 examples/constant_prop_sessions.rs create mode 100644 examples/constant_prop_sessions_async.rs rename src/instances/{pseudo_singleton.rs => session_runtime.rs} (85%) delete mode 100644 tests/pseudo_singleton_constant_prop.rs rename examples/support/pseudo_singleton_constant_prop.rs => tests/session_tx_constant_prop.rs (88%) rename tests/{session_aware_tx.rs => tx_sessions.rs} (100%) diff --git a/README.md b/README.md index 4adfde3..b65d41b 100644 --- a/README.md +++ b/README.md @@ -141,7 +141,7 @@ fn main() { } ``` -`tx_rx_vt_pr!` now generates a session-aware `Tx` facade by default. +`tx_rx_vt_pr!` now generates the default `Tx` facade as a session-routed runtime. - Calls like `MyTx::add_rule(...)`, `MyTx::run_ruleset(...)`, and `MyTx::canonical_raw(...)` resolve against the current active session when one is bound. @@ -150,10 +150,10 @@ fn main() { If you want to study the explicit session API in practice, see: -- `examples/constant_prop_pseudo_singleton.rs` -- `examples/constant_prop_pseudo_singleton_async.rs` +- `examples/constant_prop_sessions.rs` +- `examples/constant_prop_sessions_async.rs` -These examples use the default session-aware `MyTx::...` API together with explicit +These examples use the default `MyTx::...` API together with explicit session handles. The async version only supports explicit wrapper-based entry (`run_async` / `spawn_async`); it does not claim ambient async-task inheritance. @@ -281,17 +281,17 @@ Run it with: cargo run --example action_sample_recorder ``` -### Pseudo-Singleton Session Examples +### Session Examples -- **`examples/constant_prop_pseudo_singleton.rs`**: Demonstrates the default session-aware `tx_rx_vt_pr!` facade for constant propagation. The API still looks like `MyTx::...`, but the active runtime is selected by an explicit session handle. +- **`examples/constant_prop_sessions.rs`**: Demonstrates the default `tx_rx_vt_pr!` facade for constant propagation. The API still looks like `MyTx::...`, but the active runtime is selected by an explicit session handle. -- **`examples/constant_prop_pseudo_singleton_async.rs`**: Demonstrates the same session-aware model for explicit async wrapper entry points (`run_async`, `spawn_async`) and mixed sync/async re-entry. +- **`examples/constant_prop_sessions_async.rs`**: Demonstrates the same session model for explicit async wrapper entry points (`run_async`, `spawn_async`) and mixed sync/async re-entry. Run them with: ```bash -cargo run --example constant_prop_pseudo_singleton -cargo run --example constant_prop_pseudo_singleton_async +cargo run --example constant_prop_sessions +cargo run --example constant_prop_sessions_async ``` ### Feature-Gated Examples diff --git a/examples/constant_prop_pseudo_singleton.rs b/examples/constant_prop_pseudo_singleton.rs deleted file mode 100644 index b4b1c83..0000000 --- a/examples/constant_prop_pseudo_singleton.rs +++ /dev/null @@ -1,8 +0,0 @@ -#[path = "support/pseudo_singleton_constant_prop.rs"] -mod pseudo_singleton_constant_prop; - -fn main() { - env_logger::init(); - pseudo_singleton_constant_prop::two_isolated_sessions_keep_separate_egraphs_with_handles(); - println!("constant_prop_pseudo_singleton passed"); -} diff --git a/examples/constant_prop_pseudo_singleton_async.rs b/examples/constant_prop_pseudo_singleton_async.rs deleted file mode 100644 index b2e85f6..0000000 --- a/examples/constant_prop_pseudo_singleton_async.rs +++ /dev/null @@ -1,9 +0,0 @@ -#[path = "support/pseudo_singleton_constant_prop.rs"] -mod pseudo_singleton_constant_prop; - -fn main() { - env_logger::init(); - pseudo_singleton_constant_prop::async_sessions_can_survive_yield_and_spawn(); - pseudo_singleton_constant_prop::sync_run_can_override_outer_async_session(); - println!("constant_prop_pseudo_singleton_async passed"); -} diff --git a/examples/constant_prop_sessions.rs b/examples/constant_prop_sessions.rs new file mode 100644 index 0000000..e84d572 --- /dev/null +++ b/examples/constant_prop_sessions.rs @@ -0,0 +1,116 @@ +use eggplant::{prelude::*, tx_rx_vt_pr}; + +#[eggplant::dsl] +pub enum Expr { + Const { num: i64 }, + Mul { l: Expr, r: Expr }, + Add { l: Expr, r: Expr }, +} + +tx_rx_vt_pr!(MyTx, MyPatRec); + +macro_rules! prop { + ($rule_name:expr, $ty:ident, $op:tt, $pat_name:ident, $ruleset:ident) => {{ + MyTx::add_rule( + $rule_name, + $ruleset, + || { + let l = Const::query(); + let r = Const::query(); + let p = $ty::query(&l, &r); + #[eggplant::pat_vars_catch] + struct $pat_name { + l: Const, + r: Const, + p: $ty, + } + }, + |ctx, pat| { + let value = ctx.devalue(pat.l.num) $op ctx.devalue(pat.r.num); + let folded = ctx.insert_const(value); + ctx.union(pat.p, folded); + }, + ); + }}; +} + +fn register_constant_prop_rules() -> RuleSetId { + MyTx::get_or_register_ruleset("constant_prop", || { + let ruleset = MyTx::new_ruleset("constant_prop_sessions"); + prop!("AddPat", Add, +, AddPat, ruleset); + prop!("MulPat", Mul, *, MulPat, ruleset); + ruleset + }) +} + +fn current_snapshot() -> PersistedSnapshot { + let egraph = MyTx::egraph(); + let egraph = egraph.lock().unwrap(); + build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) +} + +fn snapshot_has_const(snapshot: &PersistedSnapshot, needle: i64) -> bool { + let Some(const_decl) = snapshot + .schema + .constructor_decls + .iter() + .find(|decl| decl.name == "Const") + else { + return false; + }; + + snapshot.state.function_rows.iter().any(|row| { + row.op_id == const_decl.op_id + && matches!( + row.inputs.first(), + Some(PersistedSnapshotValue::Lit { value, .. }) if value.value == needle.to_string() + ) + }) +} + +fn current_session_has_const(needle: i64) -> bool { + snapshot_has_const(¤t_snapshot(), needle) +} + +fn canonical_eq(lhs: &Expr, rhs_const: i64) -> bool { + let rhs: Expr = Const::new(rhs_const); + rhs.commit(); + MyTx::canonical_raw(lhs) == MyTx::canonical_raw(&rhs) +} + +fn fold_mul_add_expr(session: &Session, lhs: i64, rhs: i64, addend: i64) -> i64 { + session.run(|| { + let expr: Expr = Add::new( + &Mul::new(&Const::new(lhs), &Const::new(rhs)), + &Const::new(addend), + ); + expr.commit(); + + let ruleset = register_constant_prop_rules(); + let _ = MyTx::run_ruleset(ruleset, RunConfig::Sat); + + let expected = lhs * rhs + addend; + assert!(canonical_eq(&expr, expected)); + expected + }) +} + +fn session_has_const(session: &Session, needle: i64) -> bool { + session.run(|| current_session_has_const(needle)) +} + +fn main() { + env_logger::init(); + + let left = MyTx::new_session(); + let right = MyTx::new_session(); + + assert_eq!(fold_mul_add_expr(&left, 3, 2, 4), 10); + assert_eq!(fold_mul_add_expr(&right, 5, 5, 1), 26); + assert!(session_has_const(&left, 10)); + assert!(!session_has_const(&left, 26)); + assert!(session_has_const(&right, 26)); + assert!(!session_has_const(&right, 10)); + + println!("constant_prop_sessions passed"); +} diff --git a/examples/constant_prop_sessions_async.rs b/examples/constant_prop_sessions_async.rs new file mode 100644 index 0000000..0482047 --- /dev/null +++ b/examples/constant_prop_sessions_async.rs @@ -0,0 +1,141 @@ +use eggplant::{prelude::*, tx_rx_vt_pr}; + +#[eggplant::dsl] +pub enum Expr { + Const { num: i64 }, + Mul { l: Expr, r: Expr }, + Add { l: Expr, r: Expr }, +} + +tx_rx_vt_pr!(MyTx, MyPatRec); + +macro_rules! prop { + ($rule_name:expr, $ty:ident, $op:tt, $pat_name:ident, $ruleset:ident) => {{ + MyTx::add_rule( + $rule_name, + $ruleset, + || { + let l = Const::query(); + let r = Const::query(); + let p = $ty::query(&l, &r); + #[eggplant::pat_vars_catch] + struct $pat_name { + l: Const, + r: Const, + p: $ty, + } + }, + |ctx, pat| { + let value = ctx.devalue(pat.l.num) $op ctx.devalue(pat.r.num); + let folded = ctx.insert_const(value); + ctx.union(pat.p, folded); + }, + ); + }}; +} + +fn register_constant_prop_rules() -> RuleSetId { + MyTx::get_or_register_ruleset("constant_prop", || { + let ruleset = MyTx::new_ruleset("constant_prop_sessions_async"); + prop!("AddPat", Add, +, AddPat, ruleset); + prop!("MulPat", Mul, *, MulPat, ruleset); + ruleset + }) +} + +fn current_snapshot() -> PersistedSnapshot { + let egraph = MyTx::egraph(); + let egraph = egraph.lock().unwrap(); + build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) +} + +fn snapshot_has_const(snapshot: &PersistedSnapshot, needle: i64) -> bool { + let Some(const_decl) = snapshot + .schema + .constructor_decls + .iter() + .find(|decl| decl.name == "Const") + else { + return false; + }; + + snapshot.state.function_rows.iter().any(|row| { + row.op_id == const_decl.op_id + && matches!( + row.inputs.first(), + Some(PersistedSnapshotValue::Lit { value, .. }) if value.value == needle.to_string() + ) + }) +} + +fn current_session_has_const(needle: i64) -> bool { + snapshot_has_const(¤t_snapshot(), needle) +} + +fn canonical_eq(lhs: &Expr, rhs_const: i64) -> bool { + let rhs: Expr = Const::new(rhs_const); + rhs.commit(); + MyTx::canonical_raw(lhs) == MyTx::canonical_raw(&rhs) +} + +fn fold_active_mul_add_expr(lhs: i64, rhs: i64, addend: i64) -> i64 { + let expr: Expr = Add::new( + &Mul::new(&Const::new(lhs), &Const::new(rhs)), + &Const::new(addend), + ); + expr.commit(); + + let ruleset = register_constant_prop_rules(); + let _ = MyTx::run_ruleset(ruleset, RunConfig::Sat); + + let expected = lhs * rhs + addend; + assert!(canonical_eq(&expr, expected)); + expected +} + +fn main() { + env_logger::init(); + let runtime = tokio::runtime::Builder::new_multi_thread() + .worker_threads(2) + .enable_all() + .build() + .unwrap(); + + runtime.block_on(async { + let left = MyTx::new_session(); + let right = MyTx::new_session(); + + let left_value = left + .run_async(async { + tokio::task::yield_now().await; + fold_active_mul_add_expr(3, 2, 4) + }) + .await; + assert_eq!(left_value, 10); + + let right_join = right.spawn_async(async { + tokio::task::yield_now().await; + fold_active_mul_add_expr(5, 5, 1) + }); + assert_eq!(right_join.await.unwrap(), 26); + + assert!(left.run_async(async { current_session_has_const(10) }).await); + assert!(!left.run_async(async { current_session_has_const(26) }).await); + assert!(right.run_async(async { current_session_has_const(26) }).await); + assert!(!right.run_async(async { current_session_has_const(10) }).await); + + let outer = MyTx::new_session(); + let inner = MyTx::new_session(); + outer + .run_async(async { + tokio::task::yield_now().await; + let inner_value = inner.run(|| fold_active_mul_add_expr(5, 5, 1)); + assert_eq!(inner_value, 26); + assert!(inner.run(|| current_session_has_const(26))); + assert!(!outer.run(|| current_session_has_const(26))); + }) + .await; + }); + + println!("constant_prop_sessions_async passed"); +} diff --git a/src/instances/mod.rs b/src/instances/mod.rs index 470226e..c0561bf 100644 --- a/src/instances/mod.rs +++ b/src/instances/mod.rs @@ -1,5 +1,5 @@ pub mod pat_rec; -pub mod pseudo_singleton; +pub mod session_runtime; pub mod tx; pub mod tx_minimal; pub mod tx_rx_vt; @@ -150,30 +150,37 @@ macro_rules! tx_rx_vt_pr { pub struct $pat_rec_name; impl $tx_name { - pub fn new_session() -> eggplant::instances::pseudo_singleton::Session { - ::new_session() + pub fn new_session() -> eggplant::instances::session_runtime::Session { + ::new_session() } - pub fn default_session() -> eggplant::instances::pseudo_singleton::Session { - ::default_session() + pub fn default_session() -> eggplant::instances::session_runtime::Session { + ::default_session() + } + + pub fn get_or_register_ruleset( + key: &'static str, + build: impl FnOnce() -> eggplant::prelude::RuleSetId, + ) -> eggplant::prelude::RuleSetId { + eggplant::instances::session_runtime::get_or_register_ruleset::(key, build) } pub fn egraph() -> std::sync::Arc> { - eggplant::instances::pseudo_singleton::egraph::() + eggplant::instances::session_runtime::egraph::() } pub fn reset_for_bench() { - eggplant::instances::pseudo_singleton::reset_for_bench::() + eggplant::instances::session_runtime::reset_for_bench::() } } - impl eggplant::instances::pseudo_singleton::SessionAwarePatRecMarker for $pat_rec_name { + impl eggplant::instances::session_runtime::SessionPatRecMarker for $pat_rec_name { type TxMarker = $tx_name; type MetaTy = ::MetaTy; } - impl eggplant::instances::pseudo_singleton::SessionAwareTxMarker for $tx_name { + impl eggplant::instances::session_runtime::SessionTxMarker for $tx_name { type Runtime = eggplant::instances::tx_rx_vt_pr::TxRxVTPR; type PatRecorder = eggplant::instances::pat_rec::PatRecorder; type PatRecMarker = $pat_rec_name; @@ -198,30 +205,28 @@ macro_rules! tx_rx_vt_pr { } impl eggplant::prelude::SingletonGetter for $tx_name { - type RetTy = eggplant::instances::pseudo_singleton::SessionTxFacade<$tx_name>; + type RetTy = eggplant::instances::session_runtime::TxFacade<$tx_name>; fn sgl() -> &'static Self::RetTy { - static FACADE: eggplant::instances::pseudo_singleton::SessionTxFacade<$tx_name> = - eggplant::instances::pseudo_singleton::SessionTxFacade::new(); + static FACADE: eggplant::instances::session_runtime::TxFacade<$tx_name> = + eggplant::instances::session_runtime::TxFacade::new(); &FACADE } } impl eggplant::prelude::SingletonGetter for $pat_rec_name { - type RetTy = - eggplant::instances::pseudo_singleton::SessionPatRecFacade<$pat_rec_name>; + type RetTy = eggplant::instances::session_runtime::PatRecFacade<$pat_rec_name>; fn sgl() -> &'static Self::RetTy { - static FACADE: eggplant::instances::pseudo_singleton::SessionPatRecFacade< - $pat_rec_name, - > = eggplant::instances::pseudo_singleton::SessionPatRecFacade::new(); + static FACADE: eggplant::instances::session_runtime::PatRecFacade<$pat_rec_name> = + eggplant::instances::session_runtime::PatRecFacade::new(); &FACADE } } impl eggplant::wrap::NonPatRecSgl for $tx_name { fn egraph() -> std::sync::Arc> { - eggplant::instances::pseudo_singleton::egraph::<$tx_name>() + eggplant::instances::session_runtime::egraph::<$tx_name>() } } diff --git a/src/instances/pseudo_singleton.rs b/src/instances/session_runtime.rs similarity index 85% rename from src/instances/pseudo_singleton.rs rename to src/instances/session_runtime.rs index 0538d45..dd22c52 100644 --- a/src/instances/pseudo_singleton.rs +++ b/src/instances/session_runtime.rs @@ -27,7 +27,7 @@ struct ErasedSessionBinding { } impl ErasedSessionBinding { - fn new(state: Arc>) -> Self { + fn new(state: Arc>) -> Self { Self { state, order: NEXT_BINDING_ORDER.fetch_add(1, Ordering::Relaxed), @@ -52,14 +52,14 @@ enum RulesetRegistration { Ready(RuleSetId), } -struct SessionState { +struct SessionState { runtime: Tx::Runtime, pat_recorder: Mutex, rulesets: Mutex>, rulesets_cv: Condvar, } -impl SessionState { +impl SessionState { fn new() -> Self { Self { runtime: Tx::new_runtime(), @@ -74,20 +74,20 @@ fn type_key() -> TypeId { TypeId::of::() } -fn erase_state(state: Arc>) -> ErasedState { +fn erase_state(state: Arc>) -> ErasedState { state } -fn downcast_state(state: ErasedState) -> Arc> { +fn downcast_state(state: ErasedState) -> Arc> { state.downcast::>().unwrap_or_else(|_| { panic!( - "pseudo-singleton state type mismatch for {}", + "session-runtime state type mismatch for {}", std::any::type_name::() ) }) } -fn default_state() -> Arc> { +fn default_state() -> Arc> { let key = type_key::(); let mut registry = DEFAULT_SESSIONS .get_or_init(|| Mutex::new(HashMap::new())) @@ -108,7 +108,7 @@ fn task_bindings_snapshot() -> HashMap { .unwrap_or_default() } -fn current_state() -> Arc> { +fn current_state() -> Arc> { let key = type_key::(); let thread_binding = CURRENT_SESSION_THREADS.with(|slot| slot.borrow().get(&key).cloned()); let task_binding = CURRENT_SESSION_TASKS @@ -130,12 +130,12 @@ fn current_state() -> Arc> { } } -pub fn with_runtime(f: impl FnOnce(&Tx::Runtime) -> R) -> R { +pub fn with_runtime(f: impl FnOnce(&Tx::Runtime) -> R) -> R { let state = current_state::(); f(&state.runtime) } -pub fn with_pat_recorder( +pub fn with_pat_recorder( f: impl FnOnce(&Tx::PatRecorder) -> R, ) -> R { let state = current_state::(); @@ -143,11 +143,11 @@ pub fn with_pat_recorder( f(&pat_recorder) } -pub struct Session { +pub struct Session { state: Arc>, } -impl Clone for Session { +impl Clone for Session { fn clone(&self) -> Self { Self { state: Arc::clone(&self.state), @@ -155,7 +155,7 @@ impl Clone for Session { } } -impl Session { +impl Session { pub fn new() -> Self { Self { state: Arc::new(SessionState::::new()), @@ -247,7 +247,7 @@ impl Session { } } -fn get_or_register_ruleset_state( +fn get_or_register_ruleset_state( state: &Arc>, key: &'static str, build: impl FnOnce() -> RuleSetId, @@ -295,7 +295,7 @@ fn get_or_register_ruleset_state( } } -pub fn get_or_register_ruleset( +pub fn get_or_register_ruleset( key: &'static str, build: impl FnOnce() -> RuleSetId, ) -> RuleSetId { @@ -303,7 +303,7 @@ pub fn get_or_register_ruleset( get_or_register_ruleset_state::(&state, key, build) } -pub fn reset_for_bench() { +pub fn reset_for_bench() { let state = current_state::(); Tx::reset_runtime_for_bench(&state.runtime); *state.pat_recorder.lock().unwrap() = Tx::new_pat_recorder(); @@ -312,11 +312,11 @@ pub fn reset_for_bench() { state.rulesets_cv.notify_all(); } -pub fn egraph() -> Arc> { +pub fn egraph() -> Arc> { with_runtime::(Tx::runtime_egraph) } -pub trait SessionAwareTxMarker: Sized + 'static { +pub trait SessionTxMarker: Sized + 'static { type Runtime: Tx + Rx + VersionCtl @@ -329,7 +329,7 @@ pub trait SessionAwareTxMarker: Sized + 'static { + Send + Sync + 'static; - type PatRecorder: PatRec::MetaTy> + type PatRecorder: PatRec::MetaTy> + NodeOwner + NodeDropper + NodeSetter @@ -337,7 +337,7 @@ pub trait SessionAwareTxMarker: Sized + 'static { + Send + Sync + 'static; - type PatRecMarker: SessionAwarePatRecMarker + PatRecSgl; + type PatRecMarker: SessionPatRecMarker + PatRecSgl; fn new_runtime() -> Self::Runtime; fn new_pat_recorder() -> Self::PatRecorder; @@ -345,12 +345,12 @@ pub trait SessionAwareTxMarker: Sized + 'static { fn reset_runtime_for_bench(runtime: &Self::Runtime); } -pub trait SessionAwarePatRecMarker: Sized + 'static { - type TxMarker: SessionAwareTxMarker; +pub trait SessionPatRecMarker: Sized + 'static { + type TxMarker: SessionTxMarker; type MetaTy: crate::wrap::Meta; } -pub trait SessionAwareTxSgl: SessionAwareTxMarker { +pub trait SessionTxSgl: SessionTxMarker { fn new_session() -> Session { Session::new() } @@ -360,34 +360,34 @@ pub trait SessionAwareTxSgl: SessionAwareTxMarker { } } -impl SessionAwareTxSgl for T {} +impl SessionTxSgl for T {} -pub struct SessionTxFacade(PhantomData); +pub struct TxFacade(PhantomData); -impl SessionTxFacade { +impl TxFacade { pub const fn new() -> Self { Self(PhantomData) } } -impl NodeOwner for SessionTxFacade { +impl NodeOwner for TxFacade { type OwnerSpecDataInNode = ::OwnerSpecDataInNode; } -impl NodeDropper for SessionTxFacade { +impl NodeDropper for TxFacade { fn on_drop(&self, dropped: &mut (impl EgglogNode + 'static)) { with_runtime::(|runtime| runtime.on_drop(dropped)); } } -impl NodeSetter for SessionTxFacade { +impl NodeSetter for TxFacade { fn on_set(&self, node: &mut (impl EgglogNode + 'static)) { with_runtime::(|runtime| runtime.on_set(node)); } } -impl Tx for SessionTxFacade { +impl Tx for TxFacade { fn send(&self, sended: TxCommand) { with_runtime::(|runtime| runtime.send(sended)); } @@ -420,7 +420,7 @@ impl Tx for SessionTxFacade { } } -impl Rx for SessionTxFacade { +impl Rx for TxFacade { fn on_func_get<'a, F: EgglogFunc>( &self, input: ::Ref<'a>, @@ -447,7 +447,7 @@ impl Rx for SessionTxFacade { } } -impl VersionCtl for SessionTxFacade { +impl VersionCtl for TxFacade { fn locate_latest(&self, node: Sym) -> Sym { with_runtime::(|runtime| runtime.locate_latest(node)) } @@ -468,7 +468,7 @@ impl VersionCtl for SessionTxFacade { } } -impl TxCommit for SessionTxFacade { +impl TxCommit for TxFacade { fn on_stage(&self, node: &T) { with_runtime::(|runtime| runtime.on_stage(node)); } @@ -478,9 +478,9 @@ impl TxCommit for SessionTxFacade { } } -impl RuleRunner for SessionTxFacade +impl RuleRunner for TxFacade where - TxMarker: SessionAwareTxMarker, + TxMarker: SessionTxMarker, TxMarker::PatRecMarker: PatRecSgl, { fn add_rule>( @@ -513,7 +513,7 @@ where } } -impl ToDot for SessionTxFacade { +impl ToDot for TxFacade { fn egraph_to_dot(&self, path: impl AsRef) { with_runtime::(|runtime| runtime.egraph_to_dot(path)); } @@ -531,32 +531,32 @@ impl ToDot for SessionTxFacade { } } -pub struct SessionPatRecFacade(PhantomData); +pub struct PatRecFacade(PhantomData); -impl SessionPatRecFacade { +impl PatRecFacade { pub const fn new() -> Self { Self(PhantomData) } } -impl NodeOwner for SessionPatRecFacade { +impl NodeOwner for PatRecFacade { type OwnerSpecDataInNode = - <::PatRecorder as NodeOwner>::OwnerSpecDataInNode; + <::PatRecorder as NodeOwner>::OwnerSpecDataInNode; } -impl NodeDropper for SessionPatRecFacade { +impl NodeDropper for PatRecFacade { fn on_drop(&self, dropped: &mut (impl EgglogNode + 'static)) { with_pat_recorder::(|pat_rec| pat_rec.on_drop(dropped)); } } -impl NodeSetter for SessionPatRecFacade { +impl NodeSetter for PatRecFacade { fn on_set(&self, node: &mut (impl EgglogNode + 'static)) { with_pat_recorder::(|pat_rec| pat_rec.on_set(node)); } } -impl Tx for SessionPatRecFacade { +impl Tx for PatRecFacade { fn send(&self, sended: TxCommand) { with_pat_recorder::(|pat_rec| pat_rec.send(sended)); } @@ -582,8 +582,8 @@ impl Tx for SessionPatRecFacade } } -impl PatRec for SessionPatRecFacade { - type MetaTy = <::PatRecorder as PatRec>::MetaTy; +impl PatRec for PatRecFacade { + type MetaTy = <::PatRecorder as PatRec>::MetaTy; fn on_new_query_leaf(&self, node: &(impl EgglogNode + 'static)) { with_pat_recorder::(|pat_rec| pat_rec.on_new_query_leaf(node)); diff --git a/src/prelude.rs b/src/prelude.rs index 8db8713..97e7c19 100644 --- a/src/prelude.rs +++ b/src/prelude.rs @@ -19,7 +19,7 @@ pub use crate::artifact::{ read_binary_artifact_header_from_file, restore_persisted_snapshot_v1, }; pub use crate::instances::pat_rec::*; -pub use crate::instances::pseudo_singleton::{Session, SessionAwareTxSgl}; +pub use crate::instances::session_runtime::Session; pub use crate::instances::tx::*; pub use crate::instances::tx_minimal::*; pub use crate::instances::tx_rx_vt::*; diff --git a/tests/pseudo_singleton_constant_prop.rs b/tests/pseudo_singleton_constant_prop.rs deleted file mode 100644 index 84ba5a3..0000000 --- a/tests/pseudo_singleton_constant_prop.rs +++ /dev/null @@ -1,42 +0,0 @@ -#[path = "../examples/support/pseudo_singleton_constant_prop.rs"] -mod pseudo_singleton_constant_prop; - -#[test] -fn pseudo_singleton_constant_prop_keeps_sessions_isolated() { - pseudo_singleton_constant_prop::two_isolated_sessions_keep_separate_egraphs_with_handles(); -} - -#[test] -fn pseudo_singleton_constant_prop_can_register_rules_twice_per_session() { - pseudo_singleton_constant_prop::registers_rules_twice_in_same_session(); -} - -#[test] -fn pseudo_singleton_constant_prop_supports_explicit_cross_thread_reentry() { - pseudo_singleton_constant_prop::concurrent_sessions_can_register_rules_on_different_threads(); -} - -#[test] -fn pseudo_singleton_constant_prop_supports_async_task_local_routing() { - pseudo_singleton_constant_prop::async_sessions_can_survive_yield_and_spawn(); -} - -#[test] -fn pseudo_singleton_constant_prop_sync_run_can_override_outer_async_session() { - pseudo_singleton_constant_prop::sync_run_can_override_outer_async_session(); -} - -#[test] -fn pseudo_singleton_constant_prop_same_session_concurrent_registration_is_safe() { - pseudo_singleton_constant_prop::same_session_concurrent_registration_is_safe(); -} - -#[test] -fn pseudo_singleton_constant_prop_nested_ruleset_registration_is_safe() { - pseudo_singleton_constant_prop::nested_ruleset_registration_is_safe(); -} - -#[test] -fn pseudo_singleton_constant_prop_same_key_nested_registration_fails_fast() { - pseudo_singleton_constant_prop::nested_same_key_registration_panics_instead_of_deadlocking(); -} diff --git a/examples/support/pseudo_singleton_constant_prop.rs b/tests/session_tx_constant_prop.rs similarity index 88% rename from examples/support/pseudo_singleton_constant_prop.rs rename to tests/session_tx_constant_prop.rs index 935a5e9..19754ff 100644 --- a/examples/support/pseudo_singleton_constant_prop.rs +++ b/tests/session_tx_constant_prop.rs @@ -36,9 +36,9 @@ macro_rules! prop { }}; } -pub fn register_constant_prop_rules() -> RuleSetId { - eggplant::instances::pseudo_singleton::get_or_register_ruleset::("constant_prop", || { - let ruleset = MyTx::new_ruleset("constant_prop_pseudo_singleton"); +fn register_constant_prop_rules() -> RuleSetId { + MyTx::get_or_register_ruleset("constant_prop", || { + let ruleset = MyTx::new_ruleset("constant_prop_sessions_test"); prop!("AddPat", Add, +, AddPat, ruleset); prop!("MulPat", Mul, *, MulPat, ruleset); ruleset @@ -91,27 +91,38 @@ fn fold_active_mul_add_expr(lhs: i64, rhs: i64, addend: i64) -> i64 { let _ = MyTx::run_ruleset(ruleset, RunConfig::Sat); let expected = lhs * rhs + addend; - assert!( - canonical_eq(&expr, expected), - "expected {lhs} * {rhs} + {addend} to fold to {expected}" - ); + assert!(canonical_eq(&expr, expected)); expected } -pub fn fold_mul_add_expr(session: &Session, lhs: i64, rhs: i64, addend: i64) -> i64 { +fn fold_mul_add_expr(session: &Session, lhs: i64, rhs: i64, addend: i64) -> i64 { session.run(|| fold_active_mul_add_expr(lhs, rhs, addend)) } -pub fn session_has_const(session: &Session, needle: i64) -> bool { +fn session_has_const(session: &Session, needle: i64) -> bool { session.run(|| current_session_has_const(needle)) } -pub fn registers_rules_twice_in_same_session() { +#[test] +fn tx_sessions_keep_egraphs_isolated() { + let left = MyTx::new_session(); + let right = MyTx::new_session(); + + assert_eq!(fold_mul_add_expr(&left, 3, 2, 4), 10); + assert_eq!(fold_mul_add_expr(&right, 5, 5, 1), 26); + assert!(session_has_const(&left, 10)); + assert!(!session_has_const(&left, 26)); + assert!(session_has_const(&right, 26)); + assert!(!session_has_const(&right, 10)); +} + +#[test] +fn tx_sessions_can_register_rules_twice_per_session() { let session = MyTx::new_session(); session.run(|| { let ruleset1 = session.get_or_register_ruleset("constant_prop", || { - let ruleset = MyTx::new_ruleset("constant_prop_pseudo_singleton"); + let ruleset = MyTx::new_ruleset("constant_prop_sessions_test"); prop!("AddPat", Add, +, AddPat, ruleset); prop!("MulPat", Mul, *, MulPat, ruleset); ruleset @@ -130,7 +141,8 @@ pub fn registers_rules_twice_in_same_session() { }); } -pub fn concurrent_sessions_can_register_rules_on_different_threads() { +#[test] +fn tx_sessions_support_explicit_cross_thread_reentry() { let left = MyTx::new_session(); let right = MyTx::new_session(); @@ -145,7 +157,63 @@ pub fn concurrent_sessions_can_register_rules_on_different_threads() { assert!(!session_has_const(&right, 10)); } -pub fn same_session_concurrent_registration_is_safe() { +#[test] +fn tx_sessions_support_async_task_local_routing() { + let runtime = tokio::runtime::Builder::new_multi_thread() + .worker_threads(2) + .enable_all() + .build() + .unwrap(); + + runtime.block_on(async { + let left = MyTx::new_session(); + let right = MyTx::new_session(); + + let left_value = left + .run_async(async { + tokio::task::yield_now().await; + fold_active_mul_add_expr(3, 2, 4) + }) + .await; + assert_eq!(left_value, 10); + + let right_join = right.spawn_async(async { + tokio::task::yield_now().await; + fold_active_mul_add_expr(5, 5, 1) + }); + assert_eq!(right_join.await.unwrap(), 26); + + assert!(left.run_async(async { current_session_has_const(10) }).await); + assert!(!left.run_async(async { current_session_has_const(26) }).await); + assert!(right.run_async(async { current_session_has_const(26) }).await); + assert!(!right.run_async(async { current_session_has_const(10) }).await); + }); +} + +#[test] +fn tx_sessions_sync_run_can_override_outer_async_session() { + let runtime = tokio::runtime::Builder::new_current_thread() + .enable_all() + .build() + .unwrap(); + + runtime.block_on(async { + let outer = MyTx::new_session(); + let inner = MyTx::new_session(); + + outer + .run_async(async { + tokio::task::yield_now().await; + assert_eq!(fold_mul_add_expr(&inner, 5, 5, 1), 26); + assert!(session_has_const(&inner, 26)); + assert!(!session_has_const(&outer, 26)); + }) + .await; + }); +} + +#[test] +fn tx_sessions_same_session_concurrent_registration_is_safe() { let session = MyTx::new_session(); let barrier = Arc::new(Barrier::new(2)); @@ -154,7 +222,7 @@ pub fn same_session_concurrent_registration_is_safe() { let left = session.spawn(move || { left_barrier.wait(); let ruleset = left_session.get_or_register_ruleset("constant_prop", || { - let ruleset = MyTx::new_ruleset("constant_prop_pseudo_singleton"); + let ruleset = MyTx::new_ruleset("constant_prop_sessions_test"); prop!("AddPat", Add, +, AddPat, ruleset); prop!("MulPat", Mul, *, MulPat, ruleset); ruleset @@ -172,7 +240,7 @@ pub fn same_session_concurrent_registration_is_safe() { let right = session.spawn(move || { right_barrier.wait(); let ruleset = right_session.get_or_register_ruleset("constant_prop", || { - let ruleset = MyTx::new_ruleset("constant_prop_pseudo_singleton"); + let ruleset = MyTx::new_ruleset("constant_prop_sessions_test"); prop!("AddPat", Add, +, AddPat, ruleset); prop!("MulPat", Mul, *, MulPat, ruleset); ruleset @@ -194,7 +262,8 @@ pub fn same_session_concurrent_registration_is_safe() { assert!(right.2); } -pub fn nested_ruleset_registration_is_safe() { +#[test] +fn tx_sessions_nested_ruleset_registration_is_safe() { let session = MyTx::new_session(); let (sender, receiver) = mpsc::sync_channel(1); @@ -217,7 +286,8 @@ pub fn nested_ruleset_registration_is_safe() { handle.join().unwrap(); } -pub fn nested_same_key_registration_panics_instead_of_deadlocking() { +#[test] +fn tx_sessions_same_key_nested_registration_fails_fast() { let session = MyTx::new_session(); let panic = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { @@ -242,68 +312,3 @@ pub fn nested_same_key_registration_panics_instead_of_deadlocking() { assert!(message.contains("reentrant ruleset registration")); } - -pub fn async_sessions_can_survive_yield_and_spawn() { - let runtime = tokio::runtime::Builder::new_multi_thread() - .worker_threads(2) - .enable_all() - .build() - .unwrap(); - - runtime.block_on(async { - let left = MyTx::new_session(); - let right = MyTx::new_session(); - - let left_value = left - .run_async(async { - tokio::task::yield_now().await; - fold_active_mul_add_expr(3, 2, 4) - }) - .await; - assert_eq!(left_value, 10); - - let right_join = right.spawn_async(async { - tokio::task::yield_now().await; - fold_active_mul_add_expr(5, 5, 1) - }); - assert_eq!(right_join.await.unwrap(), 26); - - assert!(left.run_async(async { current_session_has_const(10) }).await); - assert!(!left.run_async(async { current_session_has_const(26) }).await); - assert!(right.run_async(async { current_session_has_const(26) }).await); - assert!(!right.run_async(async { current_session_has_const(10) }).await); - }); -} - -pub fn sync_run_can_override_outer_async_session() { - let runtime = tokio::runtime::Builder::new_current_thread() - .enable_all() - .build() - .unwrap(); - - runtime.block_on(async { - let outer = MyTx::new_session(); - let inner = MyTx::new_session(); - - outer - .run_async(async { - tokio::task::yield_now().await; - assert_eq!(fold_mul_add_expr(&inner, 5, 5, 1), 26); - assert!(session_has_const(&inner, 26)); - assert!(!session_has_const(&outer, 26)); - }) - .await; - }); -} - -pub fn two_isolated_sessions_keep_separate_egraphs_with_handles() { - let left = MyTx::new_session(); - let right = MyTx::new_session(); - - assert_eq!(fold_mul_add_expr(&left, 3, 2, 4), 10); - assert_eq!(fold_mul_add_expr(&right, 5, 5, 1), 26); - assert!(session_has_const(&left, 10)); - assert!(!session_has_const(&left, 26)); - assert!(session_has_const(&right, 26)); - assert!(!session_has_const(&right, 10)); -} diff --git a/tests/session_aware_tx.rs b/tests/tx_sessions.rs similarity index 100% rename from tests/session_aware_tx.rs rename to tests/tx_sessions.rs From ae1a666e24cf4699f3034c39991a6fb450537d14 Mon Sep 17 00:00:00 2001 From: MilkBlock <2386925778@qq.com> Date: Fri, 1 May 2026 22:27:45 +0800 Subject: [PATCH 3/8] ban read func --- .../eggplant_rewrite/merge_during_rebuild.rs | 18 +- .../eggplant_rewrite/repro_665_set_union.rs | 12 +- eggplant-macros/src/enum_related.rs | 294 +----------------- eggplant-macros/src/vanilla.rs | 21 +- examples/func_read_complex.rs | 32 +- src/test.rs | 28 +- 6 files changed, 71 insertions(+), 334 deletions(-) diff --git a/benches/runners/eggplant_rewrite/merge_during_rebuild.rs b/benches/runners/eggplant_rewrite/merge_during_rebuild.rs index 93d435d..d15a959 100644 --- a/benches/runners/eggplant_rewrite/merge_during_rebuild.rs +++ b/benches/runners/eggplant_rewrite/merge_during_rebuild.rs @@ -54,15 +54,17 @@ pub fn bench() { "merge_during_rebuild_check", check, || { - #[eggplant::pat_vars_catch] - struct Unit {} + let x = Node::query().i(&2_i64); + let y = Node::query().i(&3_i64); + let got = distance::query(&x, &y); + #[eggplant::pat_vars] + struct Pat { + got: i64, + } + Pat::new(got) }, - |ctx, _pat| { - let x = ctx.insert_node(2); - let y = ctx.insert_node(3); - let got = ctx - .try_read_distance(x, y) - .expect("distance(x,y) should be set"); + |ctx, pat| { + let got = ctx.devalue(pat.got); assert_eq!(got, 1); }, ); diff --git a/benches/runners/eggplant_rewrite/repro_665_set_union.rs b/benches/runners/eggplant_rewrite/repro_665_set_union.rs index 271d8a5..cd06f1c 100644 --- a/benches/runners/eggplant_rewrite/repro_665_set_union.rs +++ b/benches/runners/eggplant_rewrite/repro_665_set_union.rs @@ -66,11 +66,15 @@ pub fn bench() { "repro_665_check", check, || { - #[eggplant::pat_vars_catch] - struct Unit {} + let out = f::query(); + #[eggplant::pat_vars] + struct Pat { + out: BaseVar, + } + Pat::new(out) }, - |ctx, _pat| { - let out = ctx.try_read_f().expect("f() should be set"); + |ctx, pat| { + let out = pat.out; let set = ctx ._devalue_container::(out.val) .expect("f() output should be a set container"); diff --git a/eggplant-macros/src/enum_related.rs b/eggplant-macros/src/enum_related.rs index 8b1c0f5..2a4b8ab 100644 --- a/eggplant-macros/src/enum_related.rs +++ b/eggplant-macros/src/enum_related.rs @@ -857,20 +857,20 @@ pub fn ctx_set_fn_ts( }; ( - quote! { - #[track_caller] - #[allow(non_camel_case_types)] - fn #set_fn_name< #(#complex_generic_idents),* >(&self, #(#valued_ref_node_list,)* output:#output_param_ty) { - use #W::EgglogFunc; - use #W::Value; - use #W::Insertable; - static FUNC_ID: std::sync::OnceLock<#W::egglog::FunctionId> = std::sync::OnceLock::new(); - let key = [ - #(#field_idents.to_value(self).erase(),)* output.to_value(self).erase() - ]; - self.insert_func_tbl_cached(#func_name::<()>::FUNC_NAME, &FUNC_ID, &key); - } - }, + quote! { + #[track_caller] + #[allow(non_camel_case_types)] + fn #set_fn_name< #(#complex_generic_idents),* >(&self, #(#valued_ref_node_list,)* output:#output_param_ty) { + use #W::EgglogFunc; + use #W::Value; + use #W::Insertable; + static FUNC_ID: std::sync::OnceLock<#W::egglog::FunctionId> = std::sync::OnceLock::new(); + let key = [ + #(#field_idents.to_value(self).erase(),)* output.to_value(self).erase() + ]; + self.insert_func_tbl_cached(#func_name::<()>::FUNC_NAME, &FUNC_ID, &key); + } + }, quote! { #[track_caller] #[allow(non_camel_case_types)] @@ -892,269 +892,3 @@ pub fn ctx_set_fn_ts( }, ) } - -pub fn ctx_read_fn_ts( - variant: &syn::Variant, - output: &TokenStream, - func_name: &Ident, -) -> (TokenStream, TokenStream, TokenStream, TokenStream) { - let valued_ref_node_list: Vec = variant2valued_ref_node_list(&variant); - let field_idents = variant2field_ident(&variant); - - let complex_generic_idents = variant2mapped_ident_type_list_view_container_as_complex( - variant, - |_basic, _basic_ty| None, - |complex, _complex_ty| { - Some({ - let variant = format_ident!("V_{}", complex); - quote!( #variant :#W::EgglogEnumVariantTy) - }) - }, - ); - let (_variant_marker, variant_name) = variant2marker_name(variant); - let read_fn_name = format_ident!("read_{}", variant_name.to_string().to_snake_case()); - let read_value_fn_name = format_ident!("{}_value", read_fn_name); - let try_read_fn_name = format_ident!("try_{}", read_fn_name); - let try_read_value_fn_name = format_ident!("try_{}", read_value_fn_name); - - let returns_base = matches!( - BasicOrComplex::from(output), - BasicOrComplex::BaseType | BasicOrComplex::UserDefinedBaseType - ); - - let (read_fn, read_fn_decl, try_read_fn, try_read_fn_decl) = if returns_base { - ( - quote! { - #[track_caller] - #[allow(non_camel_case_types)] - fn #read_fn_name< #(#complex_generic_idents),* >(&self, #(#valued_ref_node_list),*) -> #output { - use #W::EgglogFunc; - use #W::Insertable; - static FUNC_ID: std::sync::OnceLock<#W::egglog::FunctionId> = std::sync::OnceLock::new(); - let key = [ - #(#field_idents.to_value(self).erase()),* - ]; - let out = self.lookup_expect_cached(#func_name::<()>::FUNC_NAME, &FUNC_ID, &key); - <#output as #W::BoxedValue>::devalue(self, out) - } - }, - quote! { - #[track_caller] - #[allow(non_camel_case_types)] - fn #read_fn_name< #(#complex_generic_idents),* >(&self, #(#valued_ref_node_list),*) -> #output; - }, - quote! { - #[track_caller] - #[allow(non_camel_case_types)] - fn #try_read_fn_name< #(#complex_generic_idents),* >(&self, #(#valued_ref_node_list),*) -> Option<#output> { - use #W::EgglogFunc; - use #W::Insertable; - static FUNC_ID: std::sync::OnceLock<#W::egglog::FunctionId> = std::sync::OnceLock::new(); - let key = [ - #(#field_idents.to_value(self).erase()),* - ]; - let out = self.lookup_cached(#func_name::<()>::FUNC_NAME, &FUNC_ID, &key)?; - Some(<#output as #W::BoxedValue>::devalue(self, out)) - } - }, - quote! { - #[track_caller] - #[allow(non_camel_case_types)] - fn #try_read_fn_name< #(#complex_generic_idents),* >(&self, #(#valued_ref_node_list),*) -> Option<#output>; - }, - ) - } else { - ( - quote! { - #[track_caller] - #[allow(non_camel_case_types)] - fn #read_fn_name< #(#complex_generic_idents),* >(&self, #(#valued_ref_node_list),*) -> #W::Value<#output> { - use #W::EgglogFunc; - use #W::Value; - use #W::Insertable; - static FUNC_ID: std::sync::OnceLock<#W::egglog::FunctionId> = std::sync::OnceLock::new(); - let key = [ - #(#field_idents.to_value(self).erase()),* - ]; - #W::Value::new(self.lookup_expect_cached(#func_name::<()>::FUNC_NAME, &FUNC_ID, &key)) - } - }, - quote! { - #[track_caller] - #[allow(non_camel_case_types)] - fn #read_fn_name< #(#complex_generic_idents),* >(&self, #(#valued_ref_node_list),*) -> #W::Value<#output>; - }, - quote! { - #[track_caller] - #[allow(non_camel_case_types)] - fn #try_read_fn_name< #(#complex_generic_idents),* >(&self, #(#valued_ref_node_list),*) -> Option<#W::Value<#output>> { - use #W::EgglogFunc; - use #W::Value; - use #W::Insertable; - static FUNC_ID: std::sync::OnceLock<#W::egglog::FunctionId> = std::sync::OnceLock::new(); - let key = [ - #(#field_idents.to_value(self).erase()),* - ]; - self.lookup_cached(#func_name::<()>::FUNC_NAME, &FUNC_ID, &key).map(#W::Value::new) - } - }, - quote! { - #[track_caller] - #[allow(non_camel_case_types)] - fn #try_read_fn_name< #(#complex_generic_idents),* >(&self, #(#valued_ref_node_list),*) -> Option<#W::Value<#output>>; - }, - ) - }; - - let read_value_fn = quote! { - #[track_caller] - #[allow(non_camel_case_types)] - fn #read_value_fn_name< #(#complex_generic_idents),* >(&self, #(#valued_ref_node_list),*) -> #W::Value<#output> { - use #W::EgglogFunc; - use #W::Value; - use #W::Insertable; - static FUNC_ID: std::sync::OnceLock<#W::egglog::FunctionId> = std::sync::OnceLock::new(); - let key = [ - #(#field_idents.to_value(self).erase()),* - ]; - #W::Value::new(self.lookup_expect_cached(#func_name::<()>::FUNC_NAME, &FUNC_ID, &key)) - } - }; - let try_read_value_fn = quote! { - #[track_caller] - #[allow(non_camel_case_types)] - fn #try_read_value_fn_name< #(#complex_generic_idents),* >(&self, #(#valued_ref_node_list),*) -> Option<#W::Value<#output>> { - use #W::EgglogFunc; - use #W::Value; - use #W::Insertable; - static FUNC_ID: std::sync::OnceLock<#W::egglog::FunctionId> = std::sync::OnceLock::new(); - let key = [ - #(#field_idents.to_value(self).erase()),* - ]; - self.lookup_cached(#func_name::<()>::FUNC_NAME, &FUNC_ID, &key).map(#W::Value::new) - } - }; - let read_value_decl = quote! { - #[track_caller] - #[allow(non_camel_case_types)] - fn #read_value_fn_name< #(#complex_generic_idents),* >(&self, #(#valued_ref_node_list),*) -> #W::Value<#output>; - }; - let try_read_value_decl = quote! { - #[track_caller] - #[allow(non_camel_case_types)] - fn #try_read_value_fn_name< #(#complex_generic_idents),* >(&self, #(#valued_ref_node_list),*) -> Option<#W::Value<#output>>; - }; - - let read_fn_pr = if returns_base { - quote! { - #[track_caller] - #[allow(non_camel_case_types)] - fn #read_fn_name< #(#complex_generic_idents),* >(&self, #(#valued_ref_node_list),*) -> #output { - self.ctx.#read_fn_name(#(#field_idents),*) - } - } - } else { - quote! { - #[track_caller] - #[allow(non_camel_case_types)] - fn #read_fn_name< #(#complex_generic_idents),* >(&self, #(#valued_ref_node_list),*) -> #W::Value<#output> { - self.ctx.#read_fn_name(#(#field_idents),*) - } - } - }; - let try_read_fn_pr = if returns_base { - quote! { - #[track_caller] - #[allow(non_camel_case_types)] - fn #try_read_fn_name< #(#complex_generic_idents),* >(&self, #(#valued_ref_node_list),*) -> Option<#output> { - self.ctx.#try_read_fn_name(#(#field_idents),*) - } - } - } else { - quote! { - #[track_caller] - #[allow(non_camel_case_types)] - fn #try_read_fn_name< #(#complex_generic_idents),* >(&self, #(#valued_ref_node_list),*) -> Option<#W::Value<#output>> { - self.ctx.#try_read_fn_name(#(#field_idents),*) - } - } - }; - let read_value_fn_pr = quote! { - #[track_caller] - #[allow(non_camel_case_types)] - fn #read_value_fn_name< #(#complex_generic_idents),* >(&self, #(#valued_ref_node_list),*) -> #W::Value<#output> { - self.ctx.#read_value_fn_name(#(#field_idents),*) - } - }; - let try_read_value_fn_pr = quote! { - #[track_caller] - #[allow(non_camel_case_types)] - fn #try_read_value_fn_name< #(#complex_generic_idents),* >(&self, #(#valued_ref_node_list),*) -> Option<#W::Value<#output>> { - self.ctx.#try_read_value_fn_name(#(#field_idents),*) - } - }; - - let read_fn_decl_pr = if returns_base { - quote! { - #[track_caller] - #[allow(non_camel_case_types)] - fn #read_fn_name< #(#complex_generic_idents),* >(&self, #(#valued_ref_node_list),*) -> #output; - } - } else { - quote! { - #[track_caller] - #[allow(non_camel_case_types)] - fn #read_fn_name< #(#complex_generic_idents),* >(&self, #(#valued_ref_node_list),*) -> #W::Value<#output>; - } - }; - let try_read_fn_decl_pr = if returns_base { - quote! { - #[track_caller] - #[allow(non_camel_case_types)] - fn #try_read_fn_name< #(#complex_generic_idents),* >(&self, #(#valued_ref_node_list),*) -> Option<#output>; - } - } else { - quote! { - #[track_caller] - #[allow(non_camel_case_types)] - fn #try_read_fn_name< #(#complex_generic_idents),* >(&self, #(#valued_ref_node_list),*) -> Option<#W::Value<#output>>; - } - }; - let read_value_decl_pr = quote! { - #[track_caller] - #[allow(non_camel_case_types)] - fn #read_value_fn_name< #(#complex_generic_idents),* >(&self, #(#valued_ref_node_list),*) -> #W::Value<#output>; - }; - let try_read_value_decl_pr = quote! { - #[track_caller] - #[allow(non_camel_case_types)] - fn #try_read_value_fn_name< #(#complex_generic_idents),* >(&self, #(#valued_ref_node_list),*) -> Option<#W::Value<#output>>; - }; - - ( - quote! { - #read_fn - #read_value_fn - #try_read_fn - #try_read_value_fn - }, - quote! { - #read_fn_decl - #read_value_decl - #try_read_fn_decl - #try_read_value_decl - }, - quote! { - #read_fn_pr - #read_value_fn_pr - #try_read_fn_pr - #try_read_value_fn_pr - }, - quote! { - #read_fn_decl_pr - #read_value_decl_pr - #try_read_fn_decl_pr - #try_read_value_decl_pr - }, - ) -} diff --git a/eggplant-macros/src/vanilla.rs b/eggplant-macros/src/vanilla.rs index 0c3bc27..8f643c6 100644 --- a/eggplant-macros/src/vanilla.rs +++ b/eggplant-macros/src/vanilla.rs @@ -100,27 +100,21 @@ pub fn func( }; let (set_fn, set_fn_decl, set_fn_pr, set_fn_decl_pr) = ctx_set_fn_ts(&variant, &output, &name_func); - let (read_fn, read_fn_decl, read_fn_pr, read_fn_decl_pr) = - ctx_read_fn_ts(&variant, &output, &name_func); let ctx_trait_name = format_ident!("{}RuleCtx", name_func); let pr_ctx_trait_name = format_ident!("{}PRRuleCtx", name_func); quote! { pub trait #ctx_trait_name { #set_fn_decl - #read_fn_decl } impl #ctx_trait_name for #W::RuleCtx<'_,'_,'_,'_> { #set_fn - #read_fn } pub trait #pr_ctx_trait_name { #set_fn_decl_pr - #read_fn_decl_pr } impl #pr_ctx_trait_name for #W::PRRuleCtx<'_,'_,'_,'_, PR> { #set_fn_pr - #read_fn_pr } } }; @@ -175,12 +169,14 @@ pub fn func( ) }); - // Support function-table queries where the output is a base sort but inputs are complex/container sorts. + // Support function-table queries where the output is a variable sort but inputs are complex/container sorts. // // Example from eggcc-extraction: `(VecOperand-length f) -> i64`, where `f: VecOperand` is complex. let can_query_base_from_complex_inputs = matches!( BasicOrComplex::from(&output), - BasicOrComplex::BaseType | BasicOrComplex::UserDefinedBaseType + BasicOrComplex::BaseType + | BasicOrComplex::UserDefinedBaseType + | BasicOrComplex::UserDefinedContainerType ) && input_types.iter().all(|ty| { matches!( BasicOrComplex::from(&ty.to_token_stream()), @@ -190,7 +186,9 @@ pub fn func( let can_query_base = matches!( BasicOrComplex::from(&output), - BasicOrComplex::BaseType | BasicOrComplex::UserDefinedBaseType + BasicOrComplex::BaseType + | BasicOrComplex::UserDefinedBaseType + | BasicOrComplex::UserDefinedContainerType ) && input_types.iter().all(|ty| { matches!( BasicOrComplex::from(&ty.to_token_stream()), @@ -518,11 +516,6 @@ pub fn relation( .iter() .map(|ty| quote!(<#ty as #W::PatVars>::Valued)) .collect::>(); - let metas_iter_chains = field_idents - .iter() - .zip(pat_field_types.iter()) - .map(|(ident, ty)| quote!(.chain(<#ty as #W::PatVars>::metas_iter(&self.#ident)))) - .collect::>(); let insert_param_types = data_struct .fields .iter() diff --git a/examples/func_read_complex.rs b/examples/func_read_complex.rs index 33d1f34..39d4b70 100644 --- a/examples/func_read_complex.rs +++ b/examples/func_read_complex.rs @@ -19,21 +19,16 @@ fn main() { // We'll seed a function-table row in a rule callback (tx_rx_vt_pr doesn't support `LeadTo::set` yet): // LeadTo(Add(1,2)) = Const(3) - let one = Const::new(1); - let two = Const::new(2); - let three = Const::new(3); + let one: Expr = Const::new(1); + let two: Expr = Const::new(2); + let three: Expr = Const::new(3); let add_1_2 = Add::::new(&one, &two); add_1_2.commit(); three.commit(); - // Also create a key that has no LeadTo row, to demo try_read_*. - let add_1_3 = Add::::new(&one, &three); - add_1_3.commit(); - // In rule callbacks, func ctx helpers take `Insertable>`. // A practical way to pass an existing node is to capture its canonical `egglog::Value` handle. let add_1_2_key: Value> = Value::new(MyTx::canonical_raw(&add_1_2)); - let add_1_3_key: Value> = Value::new(MyTx::canonical_raw(&add_1_3)); let three_key: Value> = Value::new(MyTx::canonical_raw(&three)); let seed_ruleset = MyTx::new_ruleset("seed_complex_output"); @@ -54,17 +49,18 @@ fn main() { "read_complex_output", ruleset, || { - #[eggplant::pat_vars_catch] - struct Unit {} + let one = Const::query().n(&1); + let two = Const::query().n(&2); + let add_1_2 = Add::query(&one, &two); + let out = LeadTo::query(&add_1_2); + #[eggplant::pat_vars] + struct Pat { + out: Expr, + } + Pat::new(out) }, - move |ctx, _pat| { - // Complex-output read: returns Value (opaque handle), not a concrete Rust AST. - let out_v = ctx.read_lead_to(add_1_2_key); - println!("LeadTo(Add(1,2)) -> {:?}", out_v); - - // Optional: non-panicking read for missing rows. - let missing = ctx.try_read_lead_to(add_1_3_key); - println!("try_read LeadTo(Add(1,3)) -> {}", missing.is_some()); + move |_ctx, pat| { + println!("LeadTo(Add(1,2)) -> {:?}", pat.out); }, ); diff --git a/src/test.rs b/src/test.rs index 2f70639..c7840a3 100644 --- a/src/test.rs +++ b/src/test.rs @@ -2458,7 +2458,7 @@ mod tests { } #[test] - fn func_ctx_read_smoke() { + fn func_ctx_query_smoke() { tx_rx_vt_pr!(MyTxRead, MyPatRecRead); #[eggplant::func(output=i64)] @@ -2483,15 +2483,25 @@ mod tests { let use_read = MyTxRead::new_ruleset("use_read"); MyTxRead::add_rule( - "use_read", + "use_query", use_read, || { - #[eggplant::pat_vars_catch] - struct Unit {} + let x1 = FibRead::x().named("x1"); + let x2 = FibRead::x().named("x2"); + let v1 = FibRead::query(&x1); + let v2 = FibRead::query(&x2); + #[eggplant::pat_vars] + struct Pat { + v1: i64, + v2: i64, + } + Pat::new(v1, v2) + .assert(x1.handle().eq(&1_i64)) + .assert(x2.handle().eq(&2_i64)) }, - |ctx, _pat| { - let v1 = ctx.read_fib_read(1); - let v2 = ctx.devalue(ctx.read_fib_read_value(2)); + |ctx, pat| { + let v1 = ctx.devalue(pat.v1); + let v2 = ctx.devalue(pat.v2); ctx.set_fib_read(3, v1 + v2); }, ); @@ -3501,9 +3511,7 @@ mod tests { let x2 = ctx.devalue(pat.x2); let f0 = ctx.devalue(pat.f0); let f1 = ctx.devalue(pat.f1); - if ctx.try_read_fib(x2).is_none() { - ctx.set_fib(x2, f0 + f1); - } + ctx.set_fib(x2, f0 + f1); }); MyTxFib::run_ruleset(step, RunConfig::Times(7)); From 156b9be39e74ae467415f2358d4b1cd7b9b7fd1a Mon Sep 17 00:00:00 2001 From: MilkBlock <2386925778@qq.com> Date: Wed, 6 May 2026 16:06:45 +0800 Subject: [PATCH 4/8] chore(deps): switch to upstream egglog and add proof/bench config --- .gitignore | 3 +- Cargo.lock | 278 +++++++++++++++++- Cargo.toml | 10 +- README.md | 9 + ...04-21-pseudo-singleton-review-checklist.md | 16 + eggplant-viewer/Cargo.toml | 1 + 6 files changed, 308 insertions(+), 9 deletions(-) diff --git a/.gitignore b/.gitignore index 84db323..dd56f2e 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,6 @@ target/ +target/**/*.typ +target/**/*.svg notes.md .vscode node_modules @@ -24,4 +26,3 @@ tests/*.json tools/ - diff --git a/Cargo.lock b/Cargo.lock index 00c1d08..72635cf 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -285,7 +285,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0348a1c054491f4bfe6ab86a7b6ab1e44e45d899005de92f58b3df180b36ddaf" dependencies = [ "clipboard-win", - "image", + "image 0.25.10", "log", "objc2 0.6.4", "objc2-app-kit 0.3.2", @@ -693,6 +693,12 @@ dependencies = [ "syn 2.0.117", ] +[[package]] +name = "byteorder" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" + [[package]] name = "byteorder-lite" version = "0.1.0" @@ -817,7 +823,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0" dependencies = [ "iana-time-zone", + "js-sys", "num-traits", + "wasm-bindgen", "windows-link 0.2.1", ] @@ -989,6 +997,12 @@ dependencies = [ "regex-lite", ] +[[package]] +name = "color_quant" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b" + [[package]] name = "colorchoice" version = "1.0.5" @@ -1030,6 +1044,19 @@ version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "baf0a07a401f374238ab8e2f11a104d2851bf9ce711ec69804834de8af45c7af" +[[package]] +name = "console" +version = "0.15.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8" +dependencies = [ + "encode_unicode", + "libc", + "once_cell", + "unicode-width", + "windows-sys 0.59.0", +] + [[package]] name = "core-foundation" version = "0.9.4" @@ -1080,6 +1107,18 @@ dependencies = [ "libc", ] +[[package]] +name = "core-text" +version = "20.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c9d2790b5c08465d49f8dc05c8bcae9fea467855947db39b0f8145c091aaced5" +dependencies = [ + "core-foundation 0.9.4", + "core-graphics", + "foreign-types", + "libc", +] + [[package]] name = "cpu-time" version = "1.0.0" @@ -1324,6 +1363,27 @@ dependencies = [ "crypto-common", ] +[[package]] +name = "dirs" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3e8aa94d75141228480295a7d0e7feb620b1a5ad9f12bc40be62411e38cce4e" +dependencies = [ + "dirs-sys", +] + +[[package]] +name = "dirs-sys" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab" +dependencies = [ + "libc", + "option-ext", + "redox_users", + "windows-sys 0.59.0", +] + [[package]] name = "dispatch" version = "0.2.0" @@ -1407,6 +1467,18 @@ version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d8b14ccef22fc6f5a8f4d7d768562a182c04ce9a3b3157b91390b52ddfdf1a76" +[[package]] +name = "dwrote" +version = "0.11.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e1b35532432acc8b19ceed096e35dfa088d3ea037fe4f3c085f1f97f33b4d02" +dependencies = [ + "lazy_static", + "libc", + "winapi", + "wio", +] + [[package]] name = "dyn-clone" version = "1.0.20" @@ -1440,7 +1512,7 @@ dependencies = [ "glow", "glutin", "glutin-winit", - "image", + "image 0.25.10", "js-sys", "log", "objc2 0.5.2", @@ -1569,7 +1641,6 @@ dependencies = [ "num-rational", "once_cell", "ordered-float 5.1.0", - "petgraph 0.8.3", "rayon", "smallvec", "thiserror 2.0.18", @@ -1605,6 +1676,7 @@ name = "egglog-concurrency" version = "2.0.0" dependencies = [ "arc-swap", + "bumpalo", "egglog-numeric-id 2.0.0", "rayon", "smallvec", @@ -1641,7 +1713,6 @@ dependencies = [ "log", "num", "once_cell", - "petgraph 0.8.3", "rand 0.9.2", "rayon", "rustc-hash 2.1.1", @@ -1745,6 +1816,7 @@ dependencies = [ name = "eggplant" version = "0.2.7" dependencies = [ + "clap", "codspeed-divan-compat", "crossbeam", "dashmap", @@ -1761,12 +1833,15 @@ dependencies = [ "glob", "graphviz-rust", "indexmap", + "indicatif", "inventory", "itertools 0.14.0", + "libc", "log", "mimalloc", "num", "petgraph 0.6.5", + "plotters", "rayon", "rmp-serde", "rustsat", @@ -1837,6 +1912,7 @@ dependencies = [ "crossbeam", "eframe", "egglog 2.0.0", + "egglog-numeric-id 2.0.0", "eggplant-egui_graphs", "egraph-serialize", "egui", @@ -1977,6 +2053,12 @@ dependencies = [ "serde", ] +[[package]] +name = "encode_unicode" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0" + [[package]] name = "endi" version = "1.1.1" @@ -2189,6 +2271,12 @@ dependencies = [ "miniz_oxide", ] +[[package]] +name = "float-ord" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ce81f49ae8a0482e4c55ea62ebbd7e5a686af544c00b9d090bba3ff9be97b3d" + [[package]] name = "fnv" version = "1.0.7" @@ -2207,6 +2295,31 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb" +[[package]] +name = "font-kit" +version = "0.14.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c7e611d49285d4c4b2e1727b72cf05353558885cc5252f93707b845dfcaf3d3" +dependencies = [ + "bitflags 2.11.0", + "byteorder", + "core-foundation 0.9.4", + "core-graphics", + "core-text", + "dirs", + "dwrote", + "float-ord", + "freetype-sys", + "lazy_static", + "libc", + "log", + "pathfinder_geometry", + "pathfinder_simd", + "walkdir", + "winapi", + "yeslogic-fontconfig-sys", +] + [[package]] name = "foreign-types" version = "0.5.0" @@ -2243,6 +2356,17 @@ dependencies = [ "percent-encoding", ] +[[package]] +name = "freetype-sys" +version = "0.20.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0e7edc5b9669349acfda99533e9e0bcf26a51862ab43b08ee7745c55d28eb134" +dependencies = [ + "cc", + "libc", + "pkg-config", +] + [[package]] name = "futures-channel" version = "0.3.32" @@ -2376,6 +2500,16 @@ dependencies = [ "wasip3", ] +[[package]] +name = "gif" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "80792593675e051cf94a4b111980da2ba60d4a83e43e0048c5693baab3977045" +dependencies = [ + "color_quant", + "weezl", +] + [[package]] name = "gl_generator" version = "0.14.0" @@ -2765,6 +2899,20 @@ dependencies = [ "version_check", ] +[[package]] +name = "image" +version = "0.24.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5690139d2f55868e080017335e4b94cb7414274c74f1669c84fb5feba2c9f69d" +dependencies = [ + "bytemuck", + "byteorder", + "color_quant", + "jpeg-decoder", + "num-traits", + "png 0.17.16", +] + [[package]] name = "image" version = "0.25.10" @@ -2775,7 +2923,7 @@ dependencies = [ "byteorder-lite", "moxcms", "num-traits", - "png", + "png 0.18.1", "tiff", ] @@ -2791,6 +2939,19 @@ dependencies = [ "serde_core", ] +[[package]] +name = "indicatif" +version = "0.17.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "183b3088984b400f4cfac3620d5e076c84da5364016b4f49473de574b2586235" +dependencies = [ + "console", + "number_prefix", + "portable-atomic", + "unicode-width", + "web-time", +] + [[package]] name = "instant" version = "0.1.13" @@ -2977,6 +3138,12 @@ dependencies = [ "libc", ] +[[package]] +name = "jpeg-decoder" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00810f1d8b74be64b13dbf3db89ac67740615d6c891f0e7b6179326533011a07" + [[package]] name = "js-sys" version = "0.3.91" @@ -3383,6 +3550,12 @@ dependencies = [ "syn 2.0.117", ] +[[package]] +name = "number_prefix" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3" + [[package]] name = "objc" version = "0.2.7" @@ -3701,6 +3874,12 @@ version = "11.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e" +[[package]] +name = "option-ext" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d" + [[package]] name = "orbclient" version = "0.3.51" @@ -3753,7 +3932,7 @@ version = "0.25.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "36820e9051aca1014ddc75770aab4d68bc1e9e632f0f5627c4086bc216fb583b" dependencies = [ - "ttf-parser", + "ttf-parser 0.25.1", ] [[package]] @@ -3791,6 +3970,25 @@ version = "1.0.15" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a" +[[package]] +name = "pathfinder_geometry" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b7b7e7b4ea703700ce73ebf128e1450eb69c3a8329199ffbfb9b2a0418e5ad3" +dependencies = [ + "log", + "pathfinder_simd", +] + +[[package]] +name = "pathfinder_simd" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf9027960355bf3afff9841918474a81a5f972ac6d226d518060bba758b5ad57" +dependencies = [ + "rustc_version", +] + [[package]] name = "percent-encoding" version = "2.3.2" @@ -3918,9 +4116,16 @@ version = "0.3.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747" dependencies = [ + "chrono", + "font-kit", + "image 0.24.9", + "lazy_static", "num-traits", + "pathfinder_geometry", "plotters-backend", + "plotters-bitmap", "plotters-svg", + "ttf-parser 0.20.0", "wasm-bindgen", "web-sys", ] @@ -3931,6 +4136,17 @@ version = "0.3.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a" +[[package]] +name = "plotters-bitmap" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72ce181e3f6bf82d6c1dc569103ca7b1bd964c60ba03d7e6cdfbb3e3eb7f7405" +dependencies = [ + "gif", + "image 0.24.9", + "plotters-backend", +] + [[package]] name = "plotters-svg" version = "0.3.7" @@ -3940,6 +4156,19 @@ dependencies = [ "plotters-backend", ] +[[package]] +name = "png" +version = "0.17.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82151a2fc869e011c153adc57cf2789ccb8d9906ce52c0b39a6b5697749d7526" +dependencies = [ + "bitflags 1.3.2", + "crc32fast", + "fdeflate", + "flate2", + "miniz_oxide", +] + [[package]] name = "png" version = "0.18.1" @@ -4227,6 +4456,17 @@ dependencies = [ "bitflags 2.11.0", ] +[[package]] +name = "redox_users" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac" +dependencies = [ + "getrandom 0.2.17", + "libredox", + "thiserror 2.0.18", +] + [[package]] name = "regex" version = "1.12.3" @@ -5055,6 +5295,12 @@ dependencies = [ "once_cell", ] +[[package]] +name = "ttf-parser" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "17f77d76d837a7830fe1d4f12b7b4ba4192c1888001c7164257e4bc6d21d96b4" + [[package]] name = "ttf-parser" version = "0.25.1" @@ -6266,6 +6512,15 @@ dependencies = [ "memchr", ] +[[package]] +name = "wio" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d129932f4644ac2396cb456385cbf9e63b5b30c6e8dc4820bdca4eb082037a5" +dependencies = [ + "winapi", +] + [[package]] name = "wit-bindgen" version = "0.51.0" @@ -6433,6 +6688,17 @@ version = "0.8.28" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3ae8337f8a065cfc972643663ea4279e04e7256de865aa66fe25cec5fb912d3f" +[[package]] +name = "yeslogic-fontconfig-sys" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "503a066b4c037c440169d995b869046827dbc71263f6e8f3be6d77d4f3229dbd" +dependencies = [ + "dlib", + "once_cell", + "pkg-config", +] + [[package]] name = "yoke" version = "0.8.1" diff --git a/Cargo.toml b/Cargo.toml index b0fe4cb..c7db768 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -14,6 +14,8 @@ default = ["viewer"] viewer = ["eggplant-viewer", "dep:eframe"] eggcc_extraction = [] rustsat-extract = ["dep:rustsat", "dep:rustsat-minisat"] +benchmarks = [] +timeline-plot = ["dep:plotters"] [dependencies] derive_more = { version = "2.0.1", features = [ @@ -29,6 +31,8 @@ petgraph = "0.6.5" dashmap = "6.1.0" env_logger = "0.11.8" log = "0.4.27" +clap = { version = "4.5.39", features = ["derive"] } +indicatif = "0.17.11" eggplant-macros.workspace = true eggplant-viewer = { workspace = true, optional = true } eggplant-egui_graphs = { workspace = true, optional = true } @@ -43,12 +47,14 @@ serde_json.workspace = true rmp-serde = "1.3.0" rustsat = { version = "0.7.5", optional = true } rustsat-minisat = { version = "0.7.5", optional = true } +plotters = { version = "0.3.7", optional = true } itertools.workspace = true crossbeam.workspace = true indexmap.workspace = true sha2 = "0.10" num = "0.4" tokio = { version = "1.48.0", features = ["rt", "rt-multi-thread", "macros", "sync"] } +libc = "0.2" [dev-dependencies] divan = { package = "codspeed-divan-compat", version = "4.4.1" } @@ -94,8 +100,8 @@ eggplant-macros = { path = "eggplant-macros", version = "0.2.7" } eggplant-viewer = { path = "eggplant-viewer" } eggplant-egui_graphs = { path = "eggplant-egui_graphs" } eggplant-transpiler = { path = "eggplant-transpiler", version = "0.2.7" } -egglog = { path = "../stable/egglog_sync_serialize_raw" } -egglog-reports = { path = "../stable/egglog_sync_serialize_raw/egglog-reports" } +egglog = { path = "../egglog_upstream_latest" } +egglog-reports = { path = "../egglog_upstream_latest/egglog-reports" } itertools = "0.14.0" indexmap = { version = "2.12.0", features = ["serde"] } diff --git a/README.md b/README.md index b65d41b..584f782 100644 --- a/README.md +++ b/README.md @@ -153,6 +153,9 @@ If you want to study the explicit session API in practice, see: - `examples/constant_prop_sessions.rs` - `examples/constant_prop_sessions_async.rs` +For a focused explanation of the session-routed runtime model itself, see +[`docs/skills/session-runtime.md`](docs/skills/session-runtime.md). + These examples use the default `MyTx::...` API together with explicit session handles. The async version only supports explicit wrapper-based entry (`run_async` / `spawn_async`); it does not claim ambient async-task inheritance. @@ -287,6 +290,8 @@ cargo run --example action_sample_recorder - **`examples/constant_prop_sessions_async.rs`**: Demonstrates the same session model for explicit async wrapper entry points (`run_async`, `spawn_async`) and mixed sync/async re-entry. +- **[`docs/skills/session-runtime.md`](docs/skills/session-runtime.md)**: Describes the session-routed `Tx` model itself: default-session fallback, explicit `Session` entry points, per-session ruleset isolation, and current async/threading boundaries. + Run them with: ```bash @@ -310,6 +315,10 @@ cargo run --features rustsat-extract --example rustsat_optimize_expression To view documentation, run `cargo doc --open`. +Session runtime behavior is documented in: + +- [`docs/skills/session-runtime.md`](docs/skills/session-runtime.md) + ## Contributing Welcome to submit issues! Hope you have fun! diff --git a/docs/superpowers/reviews/2026-04-21-pseudo-singleton-review-checklist.md b/docs/superpowers/reviews/2026-04-21-pseudo-singleton-review-checklist.md index 1c357c5..3fb8a9c 100644 --- a/docs/superpowers/reviews/2026-04-21-pseudo-singleton-review-checklist.md +++ b/docs/superpowers/reviews/2026-04-21-pseudo-singleton-review-checklist.md @@ -101,6 +101,21 @@ This file records the issues raised during review, one by one, with an explicit Result: Fixed and covered by a same-session concurrent registration test. +- [x] Issue 9: nested/composable ruleset registration could deadlock. + Problem: + A later review found that `get_or_register_ruleset(...)` executed `build()` while still holding the per-session ruleset mutex. That meant nested registration of another ruleset, or accidental recursion on the same key, could deadlock. + Handling: + The helper now uses a two-phase state machine: + `Building { owner }` + `Ready(RuleSetId)` + It releases the mutex before running `build()`, lets other threads wait on a condition variable for completion, and fails fast with a clear panic on same-key reentrant registration instead of deadlocking. + Evidence: + `examples/support/pseudo_singleton_runtime.rs` + `examples/support/pseudo_singleton_constant_prop.rs` + `tests/pseudo_singleton_constant_prop.rs` + Result: + Fixed and covered by both nested-different-key and same-key-reentrant regression tests. + ## Verification - [x] `cargo test --test pseudo_singleton_constant_prop` @@ -118,3 +133,4 @@ This file records the issues raised during review, one by one, with an explicit - [x] Resolved in code: reclaimable session-owned state without process-lifetime registry growth - [x] Resolved in code: mixed sync/async session override ordering - [x] Resolved in code: same-session concurrent registration safety +- [x] Resolved in code: nested/composable ruleset registration without deadlock diff --git a/eggplant-viewer/Cargo.toml b/eggplant-viewer/Cargo.toml index fe8f4e5..5a8c34e 100644 --- a/eggplant-viewer/Cargo.toml +++ b/eggplant-viewer/Cargo.toml @@ -30,6 +30,7 @@ chrono = { version = "0.4", default-features = false, features = [ "std", ] } egglog.workspace = true +egglog-numeric-id = { path = "../../egglog_upstream_latest/numeric-id" } itertools.workspace = true indexmap.workspace = true egraph-serialize = { version = "0.3.0", default-features = false, features = ["serde"] } From bed3c07aedd92577279757c3fd1fc3c6dcc87879 Mon Sep 17 00:00:00 2001 From: MilkBlock <2386925778@qq.com> Date: Wed, 6 May 2026 16:11:40 +0800 Subject: [PATCH 5/8] feat(macros): accept bare dsl attrs and inline pattern closures --- eggplant-macros/src/enum_related.rs | 4 +- eggplant-macros/src/helper.rs | 38 +- eggplant-macros/src/lib.rs | 18 +- eggplant-macros/src/slotted.rs | 4 +- eggplant-macros/src/transpiler.rs | 41 +- eggplant-macros/src/vanilla.rs | 79 +- eggplant-transpiler/src/ast/parse.rs | 8 +- .../src/bin/transpile_batch.rs | 78 +- eggplant-transpiler/src/eggplant.rs | 1079 ++++++++++------- examples/action_sample_recorder.rs | 21 +- examples/constant_prop.rs | 31 +- examples/dsl_get.rs | 1 + examples/dynamic_action_trace_demo.rs | 29 +- examples/fib.rs | 1 + examples/pat_ref.rs | 56 +- examples/relation.rs | 1 + examples/relation_transfer_story.rs | 47 +- examples/sample_trace_json.rs | 21 +- examples/tx_minimal.rs | 1 + examples/tx_rx_vt.rs | 1 + src/test.rs | 20 +- tests/inline_pat_style.rs | 25 + 22 files changed, 995 insertions(+), 609 deletions(-) create mode 100644 tests/inline_pat_style.rs diff --git a/eggplant-macros/src/enum_related.rs b/eggplant-macros/src/enum_related.rs index 2a4b8ab..3354583 100644 --- a/eggplant-macros/src/enum_related.rs +++ b/eggplant-macros/src/enum_related.rs @@ -774,7 +774,7 @@ pub fn ctx_insert_fn_ts_with_pr( fn #insert_fn_name< #(#complex_generic_idents_with_constraint),* >(&self, #(#valued_ref_node_list),*) -> #W::Value>{ use #W::Value; use #W::Insertable; - static FUNC_ID: std::sync::OnceLock<#W::egglog::FunctionId> = std::sync::OnceLock::new(); + static FUNC_ID: std::sync::OnceLock<#W::FunctionId> = std::sync::OnceLock::new(); let key = [ #(#field_idents.to_value(self).erase()),* ]; @@ -864,7 +864,7 @@ pub fn ctx_set_fn_ts( use #W::EgglogFunc; use #W::Value; use #W::Insertable; - static FUNC_ID: std::sync::OnceLock<#W::egglog::FunctionId> = std::sync::OnceLock::new(); + static FUNC_ID: std::sync::OnceLock<#W::FunctionId> = std::sync::OnceLock::new(); let key = [ #(#field_idents.to_value(self).erase(),)* output.to_value(self).erase() ]; diff --git a/eggplant-macros/src/helper.rs b/eggplant-macros/src/helper.rs index ac01a73..560bd8a 100644 --- a/eggplant-macros/src/helper.rs +++ b/eggplant-macros/src/helper.rs @@ -540,7 +540,7 @@ fn extract_template_placeholders(template: &LitStr, attr_name: &str) -> syn::Res return Err(syn::Error::new_spanned( template, format!( - "nested `{{` inside #[eggplant::{attr_name}(\"...\")] placeholder is not supported" + "nested `{{` inside #[{attr_name}(\"...\")] placeholder is not supported" ), )); } @@ -550,7 +550,7 @@ fn extract_template_placeholders(template: &LitStr, attr_name: &str) -> syn::Res if end >= chars.len() { return Err(syn::Error::new_spanned( template, - format!("unclosed `{{` in #[eggplant::{attr_name}(\"...\")] template"), + format!("unclosed `{{` in #[{attr_name}(\"...\")] template"), )); } @@ -559,7 +559,7 @@ fn extract_template_placeholders(template: &LitStr, attr_name: &str) -> syn::Res return Err(syn::Error::new_spanned( template, format!( - "empty `{{}}` placeholder is not allowed in #[eggplant::{attr_name}(\"...\")]" + "empty `{{}}` placeholder is not allowed in #[{attr_name}(\"...\")]" ), )); } @@ -574,7 +574,7 @@ fn extract_template_placeholders(template: &LitStr, attr_name: &str) -> syn::Res return Err(syn::Error::new_spanned( template, format!( - "invalid placeholder `{placeholder}` in #[eggplant::{attr_name}(\"...\")]; only simple field names like `x` or `lhs_1` are supported" + "invalid placeholder `{placeholder}` in #[{attr_name}(\"...\")]; only simple field names like `x` or `lhs_1` are supported" ), )); } @@ -588,7 +588,7 @@ fn extract_template_placeholders(template: &LitStr, attr_name: &str) -> syn::Res } return Err(syn::Error::new_spanned( template, - format!("unmatched `}}` in #[eggplant::{attr_name}(\"...\")] template"), + format!("unmatched `}}` in #[{attr_name}(\"...\")] template"), )); } _ => idx += 1, @@ -608,7 +608,7 @@ fn variant_template_tokens(variant: &Variant, attr_name: &str) -> syn::Result 1 { return Err(syn::Error::new_spanned( variant, - format!("only one #[eggplant::{attr_name}(\"...\")] attribute is allowed per variant"), + format!("only one #[{attr_name}(\"...\")] attribute is allowed per variant"), )); } @@ -631,7 +631,7 @@ fn variant_template_tokens(variant: &Variant, attr_name: &str) -> syn::Result syn::Result syn::Result if attrs.len() > 1 { return Err(syn::Error::new_spanned( variant, - "only one #[eggplant::precedence(...)] attribute is allowed per variant", + "only one #[precedence(...)] attribute is allowed per variant", )); } @@ -827,7 +827,7 @@ mod tests { #[test] fn display_template_accepts_named_placeholders() { let variant: Variant = parse_quote! { - #[eggplant::display("{x} + {f}")] + #[display("{x} + {f}")] MDiff { x: Math, f: Math } }; let tokens = variant_display_template_tokens(&variant).unwrap(); @@ -837,7 +837,7 @@ mod tests { #[test] fn display_template_rejects_unknown_placeholder() { let variant: Variant = parse_quote! { - #[eggplant::display("{x} + {missing}")] + #[display("{x} + {missing}")] MDiff { x: Math, f: Math } }; let err = variant_display_template_tokens(&variant).unwrap_err(); @@ -847,7 +847,7 @@ mod tests { #[test] fn display_template_rejects_tuple_variant() { let variant: Variant = parse_quote! { - #[eggplant::display("{value}")] + #[display("{value}")] Wrap(Math) }; let err = variant_display_template_tokens(&variant).unwrap_err(); @@ -860,7 +860,7 @@ mod tests { #[test] fn display_template_allows_escaped_braces() { let variant: Variant = parse_quote! { - #[eggplant::display("{{x}} -> {x}")] + #[display("{{x}} -> {x}")] Wrap { x: Math } }; let tokens = variant_display_template_tokens(&variant).unwrap(); @@ -870,12 +870,12 @@ mod tests { #[test] fn typst_template_rejects_duplicate_attrs() { let variant: Variant = parse_quote! { - #[eggplant::typst("$x + $f$")] + #[typst("$x + $f$")] #[eggplant::typst("diff({x}, {f})")] MDiff { x: Math, f: Math } }; let err = variant_typst_template_tokens(&variant).unwrap_err(); - assert!(err.to_string().contains("only one #[eggplant::typst")); + assert!(err.to_string().contains("only one #[typst")); } #[test] @@ -894,7 +894,7 @@ mod tests { #[test] fn precedence_accepts_valid_integer() { let variant: Variant = parse_quote! { - #[eggplant::precedence(40)] + #[precedence(40)] Add { lhs: Expr, rhs: Expr } }; let tokens = variant_precedence_tokens(&variant).unwrap(); @@ -904,12 +904,12 @@ mod tests { #[test] fn precedence_rejects_duplicate_attrs() { let variant: Variant = parse_quote! { - #[eggplant::precedence(10)] - #[precedence(20)] + #[precedence(10)] + #[eggplant::precedence(20)] Add { lhs: Expr, rhs: Expr } }; let err = variant_precedence_tokens(&variant).unwrap_err(); - assert!(err.to_string().contains("only one #[eggplant::precedence")); + assert!(err.to_string().contains("only one #[precedence")); } } diff --git a/eggplant-macros/src/lib.rs b/eggplant-macros/src/lib.rs index 5b4f762..620cdfb 100644 --- a/eggplant-macros/src/lib.rs +++ b/eggplant-macros/src/lib.rs @@ -33,7 +33,7 @@ pub fn relation( /// /// # Example: /// -/// ``` +/// ```ignore /// #[allow(unused)] /// #[derive(Debug, Clone, EgglogTy)] /// enum Duration { @@ -48,7 +48,7 @@ pub fn relation( /// is transformed to /// /// -/// ``` +/// ```ignore /// #[derive(Debug, Clone)] /// pub struct DurationNode { /// ty: _DurationNode, @@ -198,10 +198,18 @@ pub fn container( dsl(attr, item) } +#[proc_macro_attribute] +pub fn singleton_getter( + attr: proc_macro::TokenStream, + item: proc_macro::TokenStream, +) -> proc_macro::TokenStream { + vanilla::singleton_getter(attr, item) +} + /// Transpile macro that converts egglog DSL to Rust code /// /// # Usage -/// ```rust +/// ```ignore /// datatype! { /// (datatype Math (MNum i64:args_name "num") (MAdd Math Math:args_name "l,r")) /// } @@ -234,7 +242,7 @@ pub fn datatype(input: proc_macro::TokenStream) -> proc_macro::TokenStream { } #[proc_macro] /// Transpile egglog Rewrite into Rust code -/// ```rust +/// ```ignore /// rule! { /// (datatype Math (MNum i64:args_name "num") (MAdd Math Math:args_name "l,r")) /// (rewrite (MAdd x y) (MAdd y x)) @@ -275,7 +283,7 @@ pub fn rule(input: proc_macro::TokenStream) -> proc_macro::TokenStream { #[proc_macro] /// Transpile egglog Rewrite into Rust code -/// ```rust +/// ```ignore /// egglog! { /// (datatype Math (MNum i64:args_name "num") (MAdd Math Math:args_name "l,r")) /// (rewrite (MAdd x y) (MAdd y x)) diff --git a/eggplant-macros/src/slotted.rs b/eggplant-macros/src/slotted.rs index 066172f..00b6160 100644 --- a/eggplant-macros/src/slotted.rs +++ b/eggplant-macros/src/slotted.rs @@ -16,7 +16,7 @@ use crate::{EgglogUserDefined, enum_related::*}; /// /// # Example: /// -/// ``` +/// ```ignore /// #[allow(unused)] /// #[derive(Debug, Clone, EgglogTy)] /// enum Duration { @@ -31,7 +31,7 @@ use crate::{EgglogUserDefined, enum_related::*}; /// is transformed to /// /// -/// ``` +/// ```ignore /// #[derive(Debug, Clone)] /// pub struct DurationNode { /// ty: _DurationNode, diff --git a/eggplant-macros/src/transpiler.rs b/eggplant-macros/src/transpiler.rs index 762b1fa..1891c8a 100644 --- a/eggplant-macros/src/transpiler.rs +++ b/eggplant-macros/src/transpiler.rs @@ -2,7 +2,8 @@ use eggplant_transpiler::ast::parse::Parser; use eggplant_transpiler::eggplant::{ - CodeGenOptions, EggplantCodeGenerator, convert_to_eggplant_with_source_and_program, + CodeGenOptions, EggplantCodeGenerator, TRANSPILER_FALLBACK_PANIC_PREFIX, + convert_to_eggplant_with_source_and_program, }; /// Transpiler that converts egglog DSL to Rust code @@ -33,9 +34,11 @@ impl Transpiler { // Parse the DSL program let commands = parser .get_program_from_string(None, dsl_code) - .unwrap_or_else(|_| { - // If parsing fails, return error message as Rust code - return vec![]; + .unwrap_or_else(|err| { + panic!( + "{}: macro transpiler parse failure: {}", + TRANSPILER_FALLBACK_PANIC_PREFIX, err + ); }); // Convert to eggplant commands @@ -44,8 +47,20 @@ impl Transpiler { Some("transpiled.egg".to_string()), ); - // Generate Rust code - codegen.generate_rust(&eggplant_commands) + // Generate Rust code. Unsupported egglog must fail during transpilation, not + // return Rust that falls back at runtime. + let rust = codegen.generate_rust(&eggplant_commands); + if let Some(fallback_line) = rust + .lines() + .find(|line| line.contains(TRANSPILER_FALLBACK_PANIC_PREFIX)) + { + panic!( + "{}: macro transpiler generated fallback code: {}", + TRANSPILER_FALLBACK_PANIC_PREFIX, + fallback_line.trim() + ); + } + rust } } @@ -63,11 +78,17 @@ mod tests { } #[test] - fn test_transpile_rewrite() { + fn test_transpile_rewrite_fails_fast_on_unsupported_fallback() { let transpiler = Transpiler::new(); let dsl = "(rewrite (MAdd (MNum ?a) (MNum ?b)) (MNum (+ ?a ?b)))"; - let rust = transpiler.transpile(dsl); - // The actual transpiler should generate valid Rust code - assert!(!rust.is_empty()); + let panic = std::panic::catch_unwind(|| transpiler.transpile(dsl)).unwrap_err(); + let message = if let Some(message) = panic.downcast_ref::<&str>() { + (*message).to_string() + } else if let Some(message) = panic.downcast_ref::() { + message.clone() + } else { + "panic without string payload".to_string() + }; + assert!(message.contains(TRANSPILER_FALLBACK_PANIC_PREFIX)); } } diff --git a/eggplant-macros/src/vanilla.rs b/eggplant-macros/src/vanilla.rs index 8f643c6..853fc6e 100644 --- a/eggplant-macros/src/vanilla.rs +++ b/eggplant-macros/src/vanilla.rs @@ -6,7 +6,9 @@ use crate::helper::*; use crate::helper::{E, INVE, W}; use proc_macro2::TokenStream; use quote::{ToTokens, format_ident, quote}; -use syn::{Data, DeriveInput, Field, Ident, Type, Visibility, parse_macro_input, parse_quote}; +use syn::{ + Data, DeriveInput, Field, Fields, Ident, Path, Type, Visibility, parse_macro_input, parse_quote, +}; use crate::enum_related::*; @@ -925,6 +927,81 @@ pub fn relation( expanded.into() } +pub fn singleton_getter( + attr: proc_macro::TokenStream, + item: proc_macro::TokenStream, +) -> proc_macro::TokenStream { + #[derive(Debug, FromMeta)] + struct SingletonGetterMeta { + ctor: Path, + } + + let input = parse_macro_input!(item as DeriveInput); + let args = match NestedMeta::parse_meta_list(attr.into()) { + Ok(v) => v, + Err(e) => return proc_macro::TokenStream::from(Error::from(e).write_errors()), + }; + let args = match SingletonGetterMeta::from_list(&args) { + Ok(v) => v, + Err(e) => return proc_macro::TokenStream::from(e.write_errors()), + }; + if args.ctor.segments.len() != 1 { + return proc_macro::TokenStream::from( + Error::custom("singleton_getter(ctor = ...) expects a single constructor identifier") + .write_errors(), + ); + } + let ctor = &args.ctor; + + let name = &input.ident; + let fields = match &input.data { + Data::Struct(data_struct) => match &data_struct.fields { + Fields::Named(fields) if fields.named.len() == 1 => fields, + Fields::Named(fields) => { + return proc_macro::TokenStream::from( + Error::custom(format!( + "singleton_getter currently expects exactly one named field, got {}", + fields.named.len() + )) + .write_errors(), + ); + } + _ => { + return proc_macro::TokenStream::from( + Error::custom("singleton_getter only supports structs with named fields") + .write_errors(), + ); + } + }, + _ => { + return proc_macro::TokenStream::from( + Error::custom("singleton_getter only supports structs").write_errors(), + ); + } + }; + let field = fields.named.first().expect("checked len above"); + let field_ident = field.ident.as_ref().expect("named field"); + let field_ty = &field.ty; + + let expanded = quote! { + #input + impl #W::SingletonGetter for #name { + type RetTy = #field_ty; + fn sgl() -> &'static #field_ty { + static INSTANCE: std::sync::OnceLock<#name> = std::sync::OnceLock::new(); + &INSTANCE + .get_or_init(|| -> #name { + Self { + #field_ident: #field_ty::#ctor(), + } + }) + .#field_ident + } + } + }; + expanded.into() +} + pub fn dsl( attr: proc_macro::TokenStream, item: proc_macro::TokenStream, diff --git a/eggplant-transpiler/src/ast/parse.rs b/eggplant-transpiler/src/ast/parse.rs index f2332bf..c0eec95 100644 --- a/eggplant-transpiler/src/ast/parse.rs +++ b/eggplant-transpiler/src/ast/parse.rs @@ -1681,7 +1681,13 @@ mod tests { &commands[0], Command::Datatype { name, .. } if name == "Math" )); - assert!(matches!(&commands[1], Command::Sort(_, name, None) if name == "MathVec")); + assert!(matches!( + &commands[1], + Command::Sort(_, name, Some((kind, args))) + if name == "MathVec" + && kind == "Vec" + && matches!(&args[..], [Expr::Var(_, arg)] if arg == "Math") + )); assert!(matches!( &commands[2], Command::Datatype { name, .. } if name == "Bool" diff --git a/eggplant-transpiler/src/bin/transpile_batch.rs b/eggplant-transpiler/src/bin/transpile_batch.rs index 1941f75..56515ee 100644 --- a/eggplant-transpiler/src/bin/transpile_batch.rs +++ b/eggplant-transpiler/src/bin/transpile_batch.rs @@ -2,9 +2,11 @@ use clap::Parser as ClapParser; use eggplant_transpiler::ast::parse::Parser as EgglogParser; use eggplant_transpiler::ast::{Action, Command}; use eggplant_transpiler::{ - CodeGenOptions, EggplantCodeGenerator, convert_to_eggplant_with_source_and_program, + CodeGenOptions, EggplantCodeGenerator, TRANSPILER_FALLBACK_PANIC_PREFIX, + convert_to_eggplant_with_source_and_program, }; use std::fs; +use std::panic::{AssertUnwindSafe, catch_unwind}; use std::path::{Path, PathBuf}; use std::process::ExitCode; use syn::{ @@ -56,6 +58,7 @@ struct Failure { summary: String, } +#[derive(Debug)] enum TranspileOutcome { Success(String), Failure { @@ -1212,15 +1215,29 @@ fn transpile_unit(unit: &SourceUnit) -> TranspileOutcome { }; } - let lowered = convert_to_eggplant_with_source_and_program( - &parse_outcome.commands, - Some(unit.source_name.clone()), - ); - let mut generator = EggplantCodeGenerator::with_options(CodeGenOptions { - omit_head_annotation: true, - ..CodeGenOptions::default() - }); - let generated = generator.generate_rust(&lowered); + let generated = match catch_unwind(AssertUnwindSafe(|| { + let lowered = convert_to_eggplant_with_source_and_program( + &parse_outcome.commands, + Some(unit.source_name.clone()), + ); + let mut generator = EggplantCodeGenerator::with_options(CodeGenOptions { + omit_head_annotation: true, + ..CodeGenOptions::default() + }); + generator.generate_rust(&lowered) + })) { + Ok(generated) => generated, + Err(payload) => { + let summary = panic_payload_to_string(payload.as_ref()); + if summary.contains(TRANSPILER_FALLBACK_PANIC_PREFIX) { + return TranspileOutcome::Failure { + summary, + generated: None, + }; + } + std::panic::resume_unwind(payload); + } + }; if let Some(todo_line) = generated.lines().find(|line| line.contains("TODO")) { return TranspileOutcome::Failure { @@ -1229,9 +1246,29 @@ fn transpile_unit(unit: &SourceUnit) -> TranspileOutcome { }; } + if let Some(fallback_line) = generated + .lines() + .find(|line| line.contains(TRANSPILER_FALLBACK_PANIC_PREFIX)) + { + return TranspileOutcome::Failure { + summary: fallback_line.trim().to_string(), + generated: Some(generated), + }; + } + TranspileOutcome::Success(generated) } +fn panic_payload_to_string(payload: &(dyn std::any::Any + Send)) -> String { + if let Some(message) = payload.downcast_ref::<&str>() { + (*message).to_string() + } else if let Some(message) = payload.downcast_ref::() { + message.clone() + } else { + "panic without string payload".to_string() + } +} + fn emit_generated_output( emit_dir: &Path, unit: &SourceUnit, @@ -1364,6 +1401,27 @@ mod tests { assert!(prefixed.contains("(rule ((A)) ((B)))")); } + #[test] + fn test_transpile_unit_fails_on_raw_egglog_fallback() { + let unit = SourceUnit { + display_name: "/tmp/sample.egg".to_string(), + source_name: "/tmp/sample.egg".to_string(), + source: "(rule ((unknown-rel a)) ((unknown-action a)))".to_string(), + output_stem: "sample".to_string(), + }; + + let outcome = transpile_unit(&unit); + match outcome { + TranspileOutcome::Failure { + summary, + generated: None, + } => { + assert!(summary.contains(TRANSPILER_FALLBACK_PANIC_PREFIX)); + } + other => panic!("expected raw fallback failure, got {other:?}"), + } + } + #[test] fn test_normalize_prefix_source_declarations_only_filters_rules() { let source = r#" diff --git a/eggplant-transpiler/src/eggplant.rs b/eggplant-transpiler/src/eggplant.rs index c3acc50..1ed5e6e 100644 --- a/eggplant-transpiler/src/eggplant.rs +++ b/eggplant-transpiler/src/eggplant.rs @@ -6,6 +6,9 @@ use crate::ast::*; use heck::ToSnakeCase; use std::collections::{HashMap, HashSet}; +pub const TRANSPILER_FALLBACK_PANIC_PREFIX: &str = "eggplant transpiler fallback"; +pub const RAW_EGGLOG_FALLBACK_PANIC_PREFIX: &str = TRANSPILER_FALLBACK_PANIC_PREFIX; + /// Eggplant DSL type definition #[derive(Debug, Clone, PartialEq)] pub struct DslType { @@ -123,7 +126,8 @@ pub enum EggplantCommand { }, /// Bridge include through the underlying egglog interpreter Include { file: String }, - /// Bridge an arbitrary egglog command through the underlying interpreter + /// Unsupported arbitrary egglog command. Generated code fails fast instead + /// of silently routing it through the underlying egglog interpreter. RawEgglogCommand { command: String }, } @@ -424,10 +428,20 @@ impl EggplantCodeGenerator { self.add_line(&format!("{}.pull();", expr)); } EggplantCommand::Extract { expr, variants } => { - if let Some(variants) = variants { - self.add_line(&format!("// extract requested {} variant(s)", variants)); - } - self.add_line(&format!("{}.pull();", self.expr_to_string(expr))); + let command = match variants { + Some(variants) => { + format!( + "(extract {} {})", + expr_to_egglog_command_string(expr), + variants + ) + } + None => format!("(extract {})", expr_to_egglog_command_string(expr)), + }; + panic!( + "{}: unsupported extract command: {}", + TRANSPILER_FALLBACK_PANIC_PREFIX, command + ); } EggplantCommand::RunRuleset(ruleset, config) => { if !self.options.omit_run_ruleset_calls { @@ -442,50 +456,28 @@ impl EggplantCodeGenerator { limit, until, } => { - let mut command = format!("(run {}", ruleset); - if let Some(limit) = limit { - command.push_str(&format!(" {}", limit)); - } - command.push_str(&format!( - " :until {})", - fact_to_egglog_command_string(until) - )); - self.add_line("let outputs = {"); - self.indent(); - self.add_line("let mut egraph = MyTx::sgl().egraph.lock().unwrap();"); - self.add_line(&format!( - "egraph.parse_and_run_program(None, {:?}).unwrap()", - command - )); - self.dedent(); - self.add_line("};"); - self.add_line("for output in outputs {"); - self.indent(); - self.add_line("print!(\"{}\", output);"); - self.dedent(); - self.add_line("}"); + let schedule = Schedule::Run { + ruleset: Some(ruleset.clone()), + limit: *limit, + until: Some(until.clone()), + }; + let command = format!( + "(run-schedule {})", + schedule_to_egglog_schedule_string(&schedule) + ); + self.add_raw_egglog_command(&command); } EggplantCommand::RunSchedule { schedules } => { - let schedule_program = schedules - .iter() - .map(ToString::to_string) - .collect::>() - .join(" "); - let command = format!("(run-schedule {schedule_program})"); - self.add_line("let outputs = {"); - self.indent(); - self.add_line("let mut egraph = MyTx::sgl().egraph.lock().unwrap();"); - self.add_line(&format!( - "egraph.parse_and_run_program(None, {:?}).unwrap()", - command - )); - self.dedent(); - self.add_line("};"); - self.add_line("for output in outputs {"); - self.indent(); - self.add_line("print!(\"{}\", output);"); - self.dedent(); - self.add_line("}"); + if schedules.iter().any(schedule_has_until) { + let command = run_schedule_to_egglog_command_string(schedules); + self.add_raw_egglog_command(&command); + } else { + self.add_line(&format!( + "let schedule = {};", + schedule_items_to_rust_expr(schedules) + )); + self.add_line("let _report = MyTx::run_schedule(schedule);"); + } } EggplantCommand::Assert { expr, expected } => { self.add_line(&format!( @@ -527,20 +519,10 @@ impl EggplantCodeGenerator { } command.push(')'); - self.add_line("let outputs = {"); - self.indent(); - self.add_line("let mut egraph = MyTx::sgl().egraph.lock().unwrap();"); - self.add_line(&format!( - "egraph.parse_and_run_program(None, {:?}).unwrap()", - command - )); - self.dedent(); - self.add_line("};"); - self.add_line("for output in outputs {"); - self.indent(); - self.add_line("print!(\"{}\", output);"); - self.dedent(); - self.add_line("}"); + panic!( + "{}: unsupported print-size: {}", + TRANSPILER_FALLBACK_PANIC_PREFIX, command + ); } EggplantCommand::PrintFunction { name, @@ -560,57 +542,31 @@ impl EggplantCodeGenerator { } command.push(')'); - self.add_line("let outputs = {"); - self.indent(); - self.add_line("let mut egraph = MyTx::sgl().egraph.lock().unwrap();"); - self.add_line(&format!( - "egraph.parse_and_run_program(None, {:?}).unwrap()", - command - )); - self.dedent(); - self.add_line("};"); - self.add_line("for output in outputs {"); - self.indent(); - self.add_line("print!(\"{}\", output);"); - self.dedent(); - self.add_line("}"); + panic!( + "{}: unsupported print-function: {}", + TRANSPILER_FALLBACK_PANIC_PREFIX, command + ); } EggplantCommand::Include { file } => { let command = format!("(include {:?})", file); - self.add_line("let outputs = {"); - self.indent(); - self.add_line("let mut egraph = MyTx::sgl().egraph.lock().unwrap();"); - self.add_line(&format!( - "egraph.parse_and_run_program(None, {:?}).unwrap()", - command - )); - self.dedent(); - self.add_line("};"); - self.add_line("for output in outputs {"); - self.indent(); - self.add_line("print!(\"{}\", output);"); - self.dedent(); - self.add_line("}"); + panic!( + "{}: unsupported include: {}", + TRANSPILER_FALLBACK_PANIC_PREFIX, command + ); } EggplantCommand::RawEgglogCommand { command } => { - self.add_line("let outputs = {"); - self.indent(); - self.add_line("let mut egraph = MyTx::sgl().egraph.lock().unwrap();"); - self.add_line(&format!( - "egraph.parse_and_run_program(None, {:?}).unwrap()", - command - )); - self.dedent(); - self.add_line("};"); - self.add_line("for output in outputs {"); - self.indent(); - self.add_line("print!(\"{}\", output);"); - self.dedent(); - self.add_line("}"); + panic!("{}: {}", TRANSPILER_FALLBACK_PANIC_PREFIX, command); } } } + fn add_raw_egglog_command(&mut self, command: &str) { + self.add_line(&format!( + "let _outputs = MyTx::egraph().lock().unwrap().parse_and_run_program(None, {}).unwrap();", + rust_raw_string_literal(command) + )); + } + fn expr_to_string(&self, expr: &Expr) -> String { match expr { Expr::Lit(_, lit) => match lit { @@ -900,11 +856,11 @@ pub fn convert_to_eggplant_with_source_and_program( }); } Command::Function { name, span, .. } => { - let function_type = function_types.get(name).cloned().unwrap_or(FunctionType { - name: normalize_identifier(name), - fields: Vec::new(), - output_type: "()".to_string(), - merge_expr: None, + let function_type = function_types.get(name).cloned().unwrap_or_else(|| { + panic!( + "{}: missing function schema for {}", + TRANSPILER_FALLBACK_PANIC_PREFIX, name + ) }); eggplant_commands.push(EggplantCommandWithSource { command: EggplantCommand::FunctionType(function_type), @@ -1168,14 +1124,18 @@ pub fn convert_to_eggplant_with_source_and_program( }, Command::Push(_) => { eggplant_commands.push(EggplantCommandWithSource { - command: EggplantCommand::Commit("current_expr".to_string()), + command: EggplantCommand::RawEgglogCommand { + command: command.to_string(), + }, source_file: source_file.clone(), source_line: Some(1), // Default line for Push command }); } Command::Pop(span, _) => { eggplant_commands.push(EggplantCommandWithSource { - command: EggplantCommand::Pull("current_expr".to_string()), + command: EggplantCommand::RawEgglogCommand { + command: command.to_string(), + }, source_file: source_file.clone(), source_line: Some(span.line), }); @@ -1288,7 +1248,13 @@ pub fn convert_to_eggplant_with_source_and_program( }); } _ => { - // Skip unsupported commands for now + eggplant_commands.push(EggplantCommandWithSource { + command: EggplantCommand::RawEgglogCommand { + command: command.to_string(), + }, + source_file: source_file.clone(), + source_line: Some(1), + }); } } } @@ -1333,6 +1299,165 @@ fn same_normalized_identifier(left: &str, right: &str) -> bool { normalize_identifier(left) == normalize_identifier(right) } +fn schedule_has_until(schedule: &Schedule) -> bool { + match schedule { + Schedule::Run { until, .. } => until.is_some(), + Schedule::Named(_) => false, + Schedule::Seq(items) | Schedule::Saturate(items) => items.iter().any(schedule_has_until), + Schedule::Repeat(_, inner) => schedule_has_until(inner), + } +} + +fn schedule_items_to_rust_expr(schedules: &[Schedule]) -> String { + match schedules { + [] => "RunSchedule::builder().build()".to_string(), + [schedule] => schedule_to_rust_expr(schedule), + _ => { + let mut expr = "RunSchedule::builder()".to_string(); + for schedule in schedules { + expr.push_str(&format!(".then({})", schedule_to_rust_expr(schedule))); + } + expr.push_str(".build()"); + expr + } + } +} + +fn schedule_to_rust_expr(schedule: &Schedule) -> String { + match schedule { + Schedule::Run { + ruleset, + limit, + until: None, + } => { + let ruleset = schedule_ruleset_expr(ruleset.as_deref()); + let run = format!("RunSchedule::builder().run({ruleset}).build()"); + match limit { + Some(limit) => { + format!( + "RunSchedule::builder().repeat({limit}, |schedule| schedule.then({run})).build()" + ) + } + None => run, + } + } + Schedule::Run { .. } => { + unreachable!("run-schedule with :until must use raw egglog bridge") + } + Schedule::Named(name) => { + format!( + "RunSchedule::builder().run({}).build()", + normalize_ruleset_name(name) + ) + } + Schedule::Seq(items) => schedule_items_to_rust_expr(items), + Schedule::Saturate(items) => match items.as_slice() { + [single] => { + if let Some(ruleset) = direct_schedule_ruleset_expr(single) { + format!("RunSchedule::builder().saturate({ruleset}).build()") + } else { + format!( + "RunSchedule::builder().saturate_schedule({}).build()", + schedule_to_rust_expr(single) + ) + } + } + _ => format!( + "RunSchedule::builder().saturate_schedule({}).build()", + schedule_items_to_rust_expr(items) + ), + }, + Schedule::Repeat(times, inner) => { + format!( + "RunSchedule::builder().repeat({times}, |schedule| schedule.then({})).build()", + schedule_to_rust_expr(inner) + ) + } + } +} + +fn direct_schedule_ruleset_expr(schedule: &Schedule) -> Option { + match schedule { + Schedule::Named(name) => Some(normalize_ruleset_name(name)), + Schedule::Run { + ruleset, + limit: None, + until: None, + } => Some(schedule_ruleset_expr(ruleset.as_deref())), + _ => None, + } +} + +fn schedule_ruleset_expr(ruleset: Option<&str>) -> String { + normalize_ruleset_name(ruleset.unwrap_or("default")) +} + +fn run_schedule_to_egglog_command_string(schedules: &[Schedule]) -> String { + let schedule_program = schedules + .iter() + .map(schedule_to_egglog_schedule_string) + .collect::>() + .join(" "); + format!("(run-schedule {schedule_program})") +} + +fn schedule_to_egglog_schedule_string(schedule: &Schedule) -> String { + match schedule { + Schedule::Run { + ruleset, + limit, + until, + } => { + let ruleset = schedule_ruleset_expr(ruleset.as_deref()); + let mut run = format!("(run {ruleset}"); + if let Some(until) = until { + run.push_str(&format!(" :until {}", fact_to_egglog_command_string(until))); + } + run.push(')'); + + match limit { + Some(limit) => format!("(repeat {limit} {run})"), + None => run, + } + } + Schedule::Named(name) => normalize_ruleset_name(name), + Schedule::Seq(items) => format!( + "(seq {})", + items + .iter() + .map(schedule_to_egglog_schedule_string) + .collect::>() + .join(" ") + ), + Schedule::Saturate(items) => format!( + "(saturate {})", + items + .iter() + .map(schedule_to_egglog_schedule_string) + .collect::>() + .join(" ") + ), + Schedule::Repeat(times, inner) => { + format!( + "(repeat {times} {})", + schedule_to_egglog_schedule_string(inner) + ) + } + } +} + +fn rust_raw_string_literal(value: &str) -> String { + let mut hashes = 1usize; + loop { + let hash_marks = "#".repeat(hashes); + let closing = format!("\"{hash_marks}"); + if !value.contains(&closing) { + return format!("r{hash_marks}\"{value}\"{hash_marks}"); + } + hashes += 1; + } +} + fn expr_type_name(expr: &Expr) -> String { match expr { Expr::Var(_, name) => normalize_identifier(name), @@ -1377,15 +1502,7 @@ fn expr_to_egglog_command_string(expr: &Expr) -> String { fn fact_to_egglog_command_string(fact: &Fact) -> String { match fact { Fact::Op(span, left, right) => { - let operator = if let Some(file) = &span.file { - if file.starts_with("operator:") { - file.trim_start_matches("operator:") - } else { - "=" - } - } else { - "=" - }; + let operator = operator_from_span(span); format!( "({} {} {})", operator, @@ -1756,8 +1873,7 @@ fn lower_rule_binding_fact( let binding_handle = if let Some(binding) = existing_binding { binding_handle_expr(&binding) } else { - let inferred_type = - infer_rule_expr_type(expr, state).unwrap_or_else(|| "i64".to_string()); + let inferred_type = infer_rule_expr_type(expr, state)?; let binding_name = ensure_base_binding(&normalized_var_name, &inferred_type, true, state)?; format!("{binding_name}.handle()") @@ -1774,8 +1890,7 @@ fn lower_rule_binding_fact( let binding_handle = if let Some(binding) = existing_binding { binding_handle_expr(&binding) } else { - let inferred_type = - infer_rule_expr_type(expr, state).unwrap_or_else(|| "i64".to_string()); + let inferred_type = infer_rule_expr_type(expr, state)?; let binding_name = ensure_base_binding(&normalized_var_name, &inferred_type, true, state)?; format!("{binding_name}.handle()") @@ -2011,7 +2126,12 @@ fn operator_from_span(span: &Span) -> &str { span.file .as_deref() .and_then(|file| file.strip_prefix("operator:")) - .unwrap_or("=") + .unwrap_or_else(|| { + panic!( + "{}: missing operator metadata for fact at line {}, column {}", + TRANSPILER_FALLBACK_PANIC_PREFIX, span.line, span.col + ) + }) } fn operator_method_name(operator: &str) -> Option<&'static str> { @@ -2512,9 +2632,10 @@ fn render_rule_base_handle_expr_with_hint( let binding = lower_constructor_fact(func_name, args, None, state)?; Some(binding_handle_expr(&binding)) } - Expr::Call(_, func_name, args) => { + Expr::Call(_, func_name, args) if supported_primitive_call(func_name) => { render_rule_primitive_handle_expr_with_hint(func_name, args, hint_type, state) } + Expr::Call(_, _, _) => None, } } @@ -2529,6 +2650,9 @@ fn render_rule_handle_expr_with_expected_type( && !state.function_types.contains_key(func_name) && find_variant_output_type(func_name, state.dsl_types).is_none() => { + if !supported_primitive_call(func_name) { + return None; + } let constraint_type = constraint_type_name(expected_type); let hint = rule_base_hint(Some(expected_type), state).map(str::to_string); let arg_exprs = args @@ -2554,17 +2678,14 @@ fn render_rule_fact_constraint_expr( let Expr::Call(_, func_name, args) = expr else { return None; }; - let arg_types = infer_primitive_fact_arg_types(func_name, args, state); + let arg_types = infer_primitive_fact_arg_types(func_name, args, state)?; let arg_exprs = args .iter() .enumerate() .map(|(index, arg)| { render_rule_fact_arg_handle_expr( arg, - arg_types - .as_ref() - .and_then(|types| types.get(index)) - .and_then(|ty| ty.as_deref()), + arg_types.get(index).and_then(|ty| ty.as_deref()), state, ) .map(|rendered| format!("{rendered}.into_handle_ty()")) @@ -2601,8 +2722,7 @@ fn render_rule_primitive_handle_expr_with_hint( ) -> Option { let output_type = hint_type .map(normalize_identifier) - .or_else(|| infer_primitive_output_type(func_name, args, state)) - .unwrap_or_else(|| "i64".to_string()); + .or_else(|| infer_primitive_output_type(func_name, args, state))?; let constraint_type = constraint_type_name(&output_type); let arg_hints = primitive_call_arg_hints(func_name, &output_type, args, state); let arg_exprs = args @@ -2977,19 +3097,15 @@ fn infer_rule_expr_type(expr: &Expr, state: &RulePatternState<'_>) -> Option, - fallback: &str, -) -> String { +fn infer_numeric_operation_type(args: &[Expr], state: &RulePatternState<'_>) -> Option { let left = args .first() .and_then(|arg| infer_rule_expr_type(arg, state)); let right = args.get(1).and_then(|arg| infer_rule_expr_type(arg, state)); if matches!(left.as_deref(), Some("f64")) || matches!(right.as_deref(), Some("f64")) { - "f64".to_string() + Some("f64".to_string()) } else { - left.or(right).unwrap_or_else(|| fallback.to_string()) + left.or(right) } } @@ -3005,14 +3121,10 @@ fn infer_primitive_output_type( "bigrat" => "BigRat".to_string(), "abs" | "min" | "max" | "neg" | "round" | "floor" | "ceil" | "sqrt" | "pow" => args .first() - .and_then(|arg| infer_rule_expr_type(arg, state)) - .unwrap_or_else(|| "i64".to_string()), + .and_then(|arg| infer_rule_expr_type(arg, state))?, "=" | "==" | "!=" | "<" | "<=" | ">" | ">=" | "and" | "or" | "not" => "bool".to_string(), - "+" | "-" | "*" | "/" | "%" => infer_numeric_operation_type(args, state, "i64"), - _ => args - .first() - .and_then(|arg| infer_rule_expr_type(arg, state)) - .unwrap_or_else(|| "i64".to_string()), + "+" | "-" | "*" | "/" | "%" => infer_numeric_operation_type(args, state)?, + _ => return None, }; Some(inferred) } @@ -3061,10 +3173,6 @@ fn container_element_type(sort_name: &str, state: &RulePatternState<'_>) -> Opti schema.args.first().cloned() } -fn normalize_runtime_call_name(func_name: &str) -> String { - normalize_identifier(func_name).to_snake_case() -} - fn render_rule_runtime_call_expr(func_name: &str, arg_exprs: &[String]) -> Option { match (func_name, arg_exprs.len()) { ("rational", 2) => Some(format!( @@ -3093,29 +3201,56 @@ fn render_rule_runtime_call_expr(func_name: &str, arg_exprs: &[String]) -> Optio | (">=", 2) | ("==", 2) | ("!=", 2) => Some(format!("({} {} {})", arg_exprs[0], func_name, arg_exprs[1])), - _ => Some(format!( - "{}({})", - normalize_runtime_call_name(func_name), - arg_exprs.join(", ") - )), + _ => None, } } +fn supported_primitive_call(func_name: &str) -> bool { + matches!( + func_name, + "rational" + | "to-f64" + | "from-string" + | "bigint" + | "numer" + | "denom" + | "bigrat" + | "abs" + | "min" + | "max" + | "neg" + | "round" + | "floor" + | "ceil" + | "sqrt" + | "pow" + | "=" + | "==" + | "!=" + | "<" + | "<=" + | ">" + | ">=" + | "and" + | "or" + | "not" + | "+" + | "-" + | "*" + | "/" + | "%" + ) +} + /// Infer type from expression context with better variable type inference fn infer_type_from_expr(expr: &Expr) -> String { match expr { Expr::Call(_, func_name, _) => normalize_identifier(func_name), - Expr::Var(_, name) => { - // For pattern variables starting with ?, try to infer type from context - if name.starts_with('?') { - // Default to String for pattern variables that might be string types - // This is a temporary solution until we have better type inference - "String".to_string() - } else { - // For other variables, default to String - "String".to_string() - } - } + Expr::Var(_, name) => panic!( + "{}: cannot infer type for unbound variable {}", + TRANSPILER_FALLBACK_PANIC_PREFIX, + normalize_identifier(name) + ), Expr::Lit(_, lit) => match lit { Literal::Int(_) => "i64".to_string(), Literal::Float(_) => "f64".to_string(), @@ -3152,9 +3287,10 @@ fn infer_variable_type_from_constructor( } } - // Fallback: if constructor not found in DSL types, use the constructor name as type - // println!("WARNING: {} infer to be itself", constructor_name); - constructor_name.to_string() + panic!( + "{}: cannot infer constructor argument type for {} at index {}", + TRANSPILER_FALLBACK_PANIC_PREFIX, constructor_name, arg_index + ) } /// Generate better pattern query with type inference, variable context, and conditions @@ -3193,16 +3329,7 @@ fn generate_pattern_query_with_context_and_conditions( for condition in conditions { if let Fact::Op(span, e1, e2) = condition { - // Extract operator from span file field (temporary hack) - let operator = if let Some(ref file) = span.file { - if file.starts_with("operator:") { - file.trim_start_matches("operator:").to_string() - } else { - "=".to_string() // Default to "=" if no operator info - } - } else { - "=".to_string() // Default to "=" if no operator info - }; + let operator = operator_from_span(span).to_string(); // Handle simple case: (Var, Lit) or (Lit, Var) if let (Expr::Var(_, var_name), Expr::Lit(_, lit)) = (e1, e2) { @@ -3268,7 +3395,10 @@ fn generate_pattern_query_with_context_and_conditions( // Generate improved pattern query with conditions using handle and assert pattern let pattern_query = if pattern_query_parts.is_empty() { - format!("// TODO: implement pattern query for {}", rule_name) + panic!( + "{}: cannot generate pattern query for {}", + TRANSPILER_FALLBACK_PANIC_PREFIX, rule_name + ) } else { let mut assert_conditions = Vec::new(); @@ -3319,7 +3449,10 @@ fn generate_pattern_query_with_context_and_conditions( ">" => format!("{}.gt(&{})", handle_call, literal_value), ">=" => format!("{}.ge(&{})", handle_call, literal_value), "!=" => format!("{}.ne(&{})", handle_call, literal_value), - _ => format!("{}.UNKNOWN(&{})", handle_call, literal_value), // default to eq + _ => panic!( + "{}: unsupported rewrite condition operator {}", + TRANSPILER_FALLBACK_PANIC_PREFIX, operator + ), }; // Generate condition variable assignment @@ -3357,7 +3490,10 @@ fn generate_pattern_query_with_context_and_conditions( ">" => format!("{}.gt(&{})", left_handle, right_handle), ">=" => format!("{}.ge(&{})", left_handle, right_handle), "!=" => format!("{}.ne(&{})", left_handle, right_handle), - _ => format!("{}.eq(&{})", left_handle, right_handle), // default to eq + _ => panic!( + "{}: unsupported rewrite condition operator {}", + TRANSPILER_FALLBACK_PANIC_PREFIX, operator + ), }; // Generate condition variable with node definitions inside the braces @@ -4081,7 +4217,6 @@ fn generate_insert_expr( ); format!("ctx.devalue(pat.{}.{})", node_name, field_name) } else { - // TODO insert function might be different when insert container // Complex type variable - use the variable directly if let Some(_var_info) = context .variables @@ -4093,12 +4228,13 @@ fn generate_insert_expr( // format!("ctx.{}(pat.{})", insert_function, normalized_var_name) format!("pat.{}", normalized_var_name) } else { - // Fallback for complex type variables - format!("pat.{}", normalized_var_name) + panic!( + "{}: RHS variable {} is not bound in the rewrite context", + TRANSPILER_FALLBACK_PANIC_PREFIX, normalized_var_name + ) } } } else { - // TODO insert function might be different when insert container // Complex type variable - we need to access its fields // Find the variable type and generate appropriate insert function if let Some(_var_info) = context @@ -4108,8 +4244,10 @@ fn generate_insert_expr( { format!("pat.{}", normalized_var_name) } else { - // Fallback for complex type variables - format!("pat.{}", normalized_var_name) + panic!( + "{}: RHS variable {} is not bound in the rewrite context", + TRANSPILER_FALLBACK_PANIC_PREFIX, normalized_var_name + ) } } } @@ -4142,14 +4280,14 @@ fn generate_insert_expr( } else { // Complex type constructor call - generate proper insert function // Get the variant information to ensure correct parameter ordering - let _variant_info = find_variant_info(func_name, dsl_types); + let has_variant = find_variant_info(func_name, dsl_types).is_some(); let arg_exprs: Vec = args .iter() .map(|arg| generate_insert_expr(arg, context, dsl_types)) .collect(); - // Generate the correct insert function name based on variant or primitve matching + // Generate the correct insert function name based on variant or primitive matching. match func_name.as_str() { "max" => { let max_prim_fn = format!("std::cmp::max"); @@ -4164,6 +4302,12 @@ fn generate_insert_expr( format!("{}({})", bitand_prim_fn, arg_exprs.join(", ")) } _ => { + if !has_variant { + panic!( + "{}: unsupported RHS constructor/function {}", + TRANSPILER_FALLBACK_PANIC_PREFIX, func_name + ); + } let insert_fn = format!("insert_{}", func_name.to_snake_case()); format!("ctx.{}({})", insert_fn, arg_exprs.join(", ")) } @@ -4224,8 +4368,10 @@ fn get_field_name_for_variable_in_constructor( } } - // Fallback: use generic field name - format!("arg{}", arg_index) + panic!( + "{}: cannot resolve field name for constructor {} at argument {}", + TRANSPILER_FALLBACK_PANIC_PREFIX, constructor_name, arg_index + ) } /// Find variant information for a constructor @@ -4378,13 +4524,11 @@ mod tests { ) })); - let rust = EggplantCodeGenerator::new() - .generate_rust(&convert_to_eggplant_with_source(&commands, None)); - - assert!(rust.contains("let _expr:Num = Num::new(7);")); - assert!(rust.contains("_expr.pull();")); - assert!(rust.contains("// extract requested 0 variant(s)")); - assert!(rust.contains("Num::new(9).pull();")); + assert_commands_codegen_fallback_panic( + &commands, + None, + &["unsupported extract command", "(extract _expr 0)"], + ); } #[test] @@ -4411,13 +4555,14 @@ mod tests { ) })); - let rust = EggplantCodeGenerator::new() - .generate_rust(&convert_to_eggplant_with_source(&commands, None)); - - assert!(rust.contains("parse_and_run_program")); - assert!(rust.contains("(print-function R 3 :file \\\"output.R3.csv.log\\\" :mode csv)")); - assert!(rust.contains("for output in outputs {")); - assert!(rust.contains("print!(\"{}\", output);")); + assert_commands_codegen_fallback_panic( + &commands, + None, + &[ + "unsupported print-function", + "(print-function R 3 :file \"output.R3.csv.log\" :mode csv)", + ], + ); } #[test] @@ -4447,13 +4592,11 @@ mod tests { .any(|cmd| { matches!(cmd, EggplantCommand::PrintSize { target: None }) }) ); - let rust = EggplantCodeGenerator::new() - .generate_rust(&convert_to_eggplant_with_source(&commands, None)); - - assert!(rust.contains("(print-size Add)")); - assert!(rust.contains("(print-size)")); - assert!(rust.contains("parse_and_run_program")); - assert!(rust.contains("print!(\"{}\", output);")); + assert_commands_codegen_fallback_panic( + &commands, + None, + &["unsupported print-size", "(print-size Add)"], + ); } #[test] @@ -4480,12 +4623,17 @@ mod tests { ) })); - let rust = EggplantCodeGenerator::new() - .generate_rust(&convert_to_eggplant_with_source(&commands, None)); - - assert!(rust.contains("parse_and_run_program")); - assert!(rust.contains("(run default_ruleset 10 :until (= (g_ a b) (g_ (IConst) b)))")); - assert!(rust.contains("for output in outputs {")); + let rust = generate_commands_without_fallback(&commands, None).unwrap(); + assert!( + rust.contains("parse_and_run_program"), + "generated Rust:\n{rust}" + ); + assert!( + rust.contains( + r##"r#"(run-schedule (repeat 10 (run default_ruleset :until (= (g_ a b) (g_ (IConst) b)))))"#"## + ), + "generated Rust:\n{rust}" + ); } #[test] @@ -4497,22 +4645,60 @@ mod tests { (run :until (= a "s")))) "#; + let mut parser = Parser::default(); + let commands = parser.get_program_from_string(None, program).unwrap(); + let rust = generate_commands_without_fallback(&commands, None).unwrap(); + assert!( + rust.contains("parse_and_run_program"), + "generated Rust:\n{rust}" + ); + assert!( + rust.contains( + r##"r#"(run-schedule (seq (run default_ruleset :until (= a 1)) (run default_ruleset :until (= a "s"))))"#"## + ), + "generated Rust:\n{rust}" + ); + assert!( + !rust.contains("RunSchedule::builder()"), + "generated Rust:\n{rust}" + ); + } + + #[test] + fn test_run_schedule_without_until_uses_builder_codegen() { + let program = r#" + (ruleset fast-analyses) + (ruleset subst) + (run-schedule + (repeat 2 + (saturate fast-analyses) + (run) + (saturate subst))) + "#; + let mut parser = Parser::default(); let commands = parser.get_program_from_string(None, program).unwrap(); let rust = EggplantCodeGenerator::new() .generate_rust(&convert_to_eggplant_with_source(&commands, None)); - assert!(rust.contains("parse_and_run_program")); - assert!(rust.contains("(run-schedule"), "generated Rust:\n{rust}"); assert!( - rust.contains("(run :until (= a 1))"), + rust.contains("RunSchedule::builder()"), + "generated Rust:\n{rust}" + ); + assert!(rust.contains(".repeat(2"), "generated Rust:\n{rust}"); + assert!( + rust.contains(".saturate(fast_analyses)"), "generated Rust:\n{rust}" ); assert!( - rust.contains("(run :until (= a \\\"s\\\"))"), + rust.contains(".run(default_ruleset)"), + "generated Rust:\n{rust}" + ); + assert!(rust.contains(".saturate(subst)"), "generated Rust:\n{rust}"); + assert!( + !rust.contains("parse_and_run_program"), "generated Rust:\n{rust}" ); - assert!(rust.contains("for output in outputs {")); } #[test] @@ -4537,15 +4723,14 @@ mod tests { ) })); - let rust = EggplantCodeGenerator::new().generate_rust(&convert_to_eggplant_with_source( + assert_commands_codegen_fallback_panic( &commands, Some(source_path.clone()), - )); - - assert!(rust.contains("parse_and_run_program")); - assert!(rust.contains( - "/Users/mineralsteins/Repos/egg_related/upstream_egglog/tests/web-demo/path.egg" - )); + &[ + "unsupported include", + "/Users/mineralsteins/Repos/egg_related/upstream_egglog/tests/web-demo/path.egg", + ], + ); } #[test] @@ -5118,19 +5303,8 @@ mod tests { let mut parser = Parser::default(); let commands = parser.get_program_from_string(None, program).unwrap(); - let rust = EggplantCodeGenerator::new() - .generate_rust(&convert_to_eggplant_with_source(&commands, None)); - - assert!( - !rust.contains("TODO: implement action for rule_"), - "unexpected TODO in generated Rust:\n{rust}" - ); - assert!( - rust.contains( - "ctx.set_ival(pat.lhs, ctx.insert_interval_union(pat.thenival, pat.elseival));" - ), - "generated Rust:\n{rust}" - ); + let message = assert_commands_codegen_fallback_panic(&commands, None, &["vec_get"]); + assert!(!message.contains("prim_call::(\"vec-get\"")); } #[test] @@ -5284,17 +5458,12 @@ mod tests { let mut parser = Parser::default(); let commands = parser.get_program_from_string(None, program).unwrap(); - let rust = EggplantCodeGenerator::new() - .generate_rust(&convert_to_eggplant_with_source(&commands, None)); - - assert!( - !rust.contains("TODO: implement action for rule_"), - "unexpected TODO in generated Rust:\n{rust}" - ); - assert!( - rust.contains("let _ = unstable_multiset_fill_index("), - "generated Rust:\n{rust}" + let message = assert_commands_codegen_fallback_panic( + &commands, + None, + &["unstable_multiset_fill_index"], ); + assert!(!message.contains("unstable_multiset_fill_index(")); } #[test] @@ -5324,7 +5493,7 @@ mod tests { } #[test] - fn test_generic_rule_fallback_bridges_raw_rule_and_normalizes_ruleset() { + fn test_generic_rule_fallback_panics_and_normalizes_ruleset() { let program = r#" (rule ((unknown-rel a b)) ((unknown-action a)) @@ -5333,29 +5502,16 @@ mod tests { let mut parser = Parser::default(); let commands = parser.get_program_from_string(None, program).unwrap(); - let rust = EggplantCodeGenerator::new() - .generate_rust(&convert_to_eggplant_with_source(&commands, None)); - - assert!( - !rust.contains("TODO: implement action for rule_"), - "unexpected TODO in generated Rust:\n{rust}" - ); - assert!( - rust.contains("parse_and_run_program"), - "generated Rust:\n{rust}" - ); - assert!( - rust.contains("(rule ((unknown_rel a b)) ((unknown_action a)) :ruleset weird_rules)"), - "generated Rust:\n{rust}" - ); - assert!( - !rust.contains(":name \\\"default\\\""), - "generated Rust:\n{rust}" + let message = assert_commands_codegen_fallback_panic( + &commands, + None, + &["(rule ((unknown_rel a b)) ((unknown_action a)) :ruleset weird_rules)"], ); + assert!(!message.contains(":name \"default\"")); } #[test] - fn test_generic_rule_fallback_bridges_default_ruleset_name() { + fn test_generic_rule_fallback_panics_with_default_ruleset_name() { let program = r#" (rule ((unknown-rel a b)) ((unknown-action a))) @@ -5363,23 +5519,30 @@ mod tests { let mut parser = Parser::default(); let commands = parser.get_program_from_string(None, program).unwrap(); - let rust = EggplantCodeGenerator::new() - .generate_rust(&convert_to_eggplant_with_source(&commands, None)); - - assert!( - !rust.contains("TODO: implement action for rule_"), - "unexpected TODO in generated Rust:\n{rust}" - ); - assert!( - rust.contains( - "(rule ((unknown_rel a b)) ((unknown_action a)) :ruleset default_ruleset)" - ), - "generated Rust:\n{rust}" + assert_commands_codegen_fallback_panic( + &commands, + None, + &["(rule ((unknown_rel a b)) ((unknown_action a)) :ruleset default_ruleset)"], ); } #[test] - fn test_check_with_fact_constraints_bridges_raw_egglog_command() { + fn test_unknown_primitive_call_panics_instead_of_prim_call_fallback() { + let program = r#" + (relation Seen (i64)) + (rule ((= x (unknown-primitive y))) + ((Seen x))) + "#; + + let mut parser = Parser::default(); + let commands = parser.get_program_from_string(None, program).unwrap(); + let message = + assert_commands_codegen_fallback_panic(&commands, None, &["unknown_primitive"]); + assert!(!message.contains("prim_call::(\"unknown-primitive\"")); + } + + #[test] + fn test_check_with_fact_constraints_panics_on_raw_egglog_fallback() { let program = r#" (check (View c1 c2) (UF_Exp c1 c1_leader) @@ -5388,17 +5551,11 @@ mod tests { let mut parser = Parser::default(); let commands = parser.get_program_from_string(None, program).unwrap(); - let rust = EggplantCodeGenerator::new() - .generate_rust(&convert_to_eggplant_with_source(&commands, None)); - - assert!( - rust.contains("parse_and_run_program"), - "generated Rust:\n{rust}" - ); + assert_commands_codegen_fallback_panic(&commands, None, &["(check"]); } #[test] - fn test_birewrite_with_conditions_bridges_raw_egglog_command() { + fn test_birewrite_with_conditions_panics_on_raw_egglog_fallback() { let program = r#" (birewrite (compose f (id B)) f :when ((= (type A) (Ob)) @@ -5407,155 +5564,146 @@ mod tests { let mut parser = Parser::default(); let commands = parser.get_program_from_string(None, program).unwrap(); - let rust = EggplantCodeGenerator::new() - .generate_rust(&convert_to_eggplant_with_source(&commands, None)); - - assert!( - rust.contains("parse_and_run_program"), - "generated Rust:\n{rust}" - ); + assert_commands_codegen_fallback_panic(&commands, None, &["(birewrite"]); } #[test] - fn test_full_program_combined_steps_has_no_generic_rule_todo() { - assert_program_has_no_generic_rule_todo( + fn test_full_program_combined_steps_fails_fast_on_unsupported_fallback() { + assert_program_fails_fast_with_fallback( "/Users/mineralsteins/Repos/egg_related/upstream_egglog/tests/test-combined-steps.egg", ); } #[test] - fn test_full_program_combinators_has_no_generic_rule_todo() { - assert_program_has_no_generic_rule_todo( + fn test_full_program_combinators_fails_fast_on_unsupported_fallback() { + assert_program_fails_fast_with_fallback( "/Users/mineralsteins/Repos/egg_related/upstream_egglog/tests/web-demo/combinators.egg", ); } #[test] - fn test_full_program_eqsolve_has_no_generic_rule_todo() { - assert_program_has_no_generic_rule_todo( + fn test_full_program_eqsolve_fails_fast_on_unsupported_fallback() { + assert_program_fails_fast_with_fallback( "/Users/mineralsteins/Repos/egg_related/upstream_egglog/tests/web-demo/eqsolve.egg", ); } #[test] - fn test_full_program_herbie_tutorial_has_no_generic_rule_todo() { - assert_program_has_no_generic_rule_todo( + fn test_full_program_herbie_tutorial_fails_fast_on_unsupported_fallback() { + assert_program_fails_fast_with_fallback( "/Users/mineralsteins/Repos/egg_related/upstream_egglog/tests/web-demo/herbie-tutorial.egg", ); } #[test] - fn test_full_program_taylor51_has_no_generic_rule_todo() { - assert_program_has_no_generic_rule_todo( + fn test_full_program_taylor51_fails_fast_on_unsupported_fallback() { + assert_program_fails_fast_with_fallback( "/Users/mineralsteins/Repos/egg_related/upstream_egglog/tests/taylor51.egg", ); } #[test] - fn test_full_program_type_constraints_tests_has_no_generic_rule_todo() { - assert_program_has_no_generic_rule_todo( + fn test_full_program_type_constraints_tests_fails_fast_on_unsupported_fallback() { + assert_program_fails_fast_with_fallback( "/Users/mineralsteins/Repos/egg_related/upstream_egglog/tests/type-constraints-tests.egg", ); } #[test] - fn test_full_program_rw_analysis_has_no_generic_rule_todo() { - assert_program_has_no_generic_rule_todo( + fn test_full_program_rw_analysis_fails_fast_on_unsupported_fallback() { + assert_program_fails_fast_with_fallback( "/Users/mineralsteins/Repos/egg_related/upstream_egglog/tests/web-demo/rw-analysis.egg", ); } #[test] - fn test_full_program_typeinfer_has_no_generic_rule_todo() { - assert_program_has_no_generic_rule_todo( + fn test_full_program_typeinfer_fails_fast_on_unsupported_fallback() { + assert_program_fails_fast_with_fallback( "/Users/mineralsteins/Repos/egg_related/upstream_egglog/tests/web-demo/typeinfer.egg", ); } #[test] - fn test_full_program_print_function_has_no_todo() { - assert_program_has_no_generic_rule_todo( + fn test_full_program_print_function_fails_fast_on_unsupported_fallback() { + assert_program_fails_fast_with_fallback( "/Users/mineralsteins/Repos/egg_related/upstream_egglog/tests/print-function.egg", ); } #[test] - fn test_full_program_hidden_print_size_has_no_todo() { - assert_program_has_no_generic_rule_todo( + fn test_full_program_hidden_print_size_fails_fast_on_unsupported_fallback() { + assert_program_fails_fast_with_fallback( "/Users/mineralsteins/Repos/egg_related/upstream_egglog/tests/hidden_print_size.egg", ); } #[test] - fn test_full_program_internal_let_has_no_todo() { - assert_program_has_no_generic_rule_todo( + fn test_full_program_internal_let_fails_fast_on_unsupported_fallback() { + assert_program_fails_fast_with_fallback( "/Users/mineralsteins/Repos/egg_related/upstream_egglog/tests/internal_let.egg", ); } #[test] - fn test_full_program_until_has_no_todo() { - assert_program_has_no_generic_rule_todo( + fn test_full_program_until_fails_fast_on_unsupported_fallback() { + assert_program_fails_fast_with_fallback( "/Users/mineralsteins/Repos/egg_related/upstream_egglog/tests/until.egg", ); } #[test] - fn test_full_program_calc_has_no_todo() { - assert_program_has_no_generic_rule_todo( + fn test_full_program_calc_fails_fast_on_unsupported_fallback() { + assert_program_fails_fast_with_fallback( "/Users/mineralsteins/Repos/egg_related/upstream_egglog/tests/calc.egg", ); } #[test] - fn test_full_program_resolution_has_no_todo() { - assert_program_has_no_generic_rule_todo( + fn test_full_program_resolution_fails_fast_on_unsupported_fallback() { + assert_program_fails_fast_with_fallback( "/Users/mineralsteins/Repos/egg_related/upstream_egglog/tests/web-demo/resolution.egg", ); } #[test] - fn test_full_program_include_has_no_todo() { + fn test_full_program_include_fails_fast_on_unsupported_fallback() { let path = "/Users/mineralsteins/Repos/egg_related/upstream_egglog/tests/include.egg"; let program = std::fs::read_to_string(path).unwrap(); let mut parser = crate::ast::parse::Parser::default(); let commands = parser .get_program_from_string(Some(path.to_string()), &program) .unwrap(); - let rust = EggplantCodeGenerator::new().generate_rust(&convert_to_eggplant_with_source( + assert_commands_codegen_fallback_panic( &commands, Some(path.to_string()), - )); - assert!( - !rust.contains("TODO"), - "unexpected TODO lines in generated Rust for {path}:\n{rust}" + &["unsupported include", "web-demo/path.egg"], ); } #[test] - fn test_full_program_egglog_bridge_math_has_no_todo() { - assert_program_has_no_generic_rule_todo( + fn test_full_program_egglog_bridge_math_fails_fast_on_unsupported_fallback() { + assert_program_fails_fast_with_fallback( "/Users/mineralsteins/Repos/egg_related/upstream_egglog/egglog-bridge/examples/math.egg", ); } #[test] - fn test_full_program_web_demo_math_has_no_todo() { - assert_program_has_no_generic_rule_todo( + fn test_full_program_web_demo_math_fails_fast_on_unsupported_fallback() { + assert_program_fails_fast_with_fallback( "/Users/mineralsteins/Repos/egg_related/upstream_egglog/tests/web-demo/math.egg", ); } #[test] - fn test_full_program_combined_nested_has_no_todo() { - assert_program_has_no_generic_rule_todo( + fn test_full_program_combined_nested_fails_fast_on_unsupported_fallback() { + assert_program_fails_fast_with_fallback( "/Users/mineralsteins/Repos/egg_related/upstream_egglog/tests/combined-nested.egg", ); } #[test] - fn test_full_program_test_combined_steps_has_no_todo() { - assert_program_has_no_generic_rule_todo( + fn test_full_program_test_combined_steps_fails_fast_on_unsupported_fallback() { + assert_program_fails_fast_with_fallback( "/Users/mineralsteins/Repos/egg_related/upstream_egglog/tests/test-combined-steps.egg", ); } @@ -5568,43 +5716,43 @@ mod tests { } #[test] - fn test_full_program_eggcc_extraction_has_no_todo() { - assert_program_has_no_generic_rule_todo( + fn test_full_program_eggcc_extraction_fails_fast_on_unsupported_fallback() { + assert_program_fails_fast_with_fallback( "/Users/mineralsteins/Repos/egg_related/upstream_egglog/tests/eggcc-extraction.egg", ); } #[test] - fn test_full_program_web_demo_prims_has_no_todo() { - assert_program_has_no_generic_rule_todo( + fn test_full_program_web_demo_prims_fails_fast_on_unsupported_fallback() { + assert_program_fails_fast_with_fallback( "/Users/mineralsteins/Repos/egg_related/upstream_egglog/tests/web-demo/prims.egg", ); } #[test] - fn test_full_program_web_demo_multiset_has_no_todo() { - assert_program_has_no_generic_rule_todo( + fn test_full_program_web_demo_multiset_fails_fast_on_unsupported_fallback() { + assert_program_fails_fast_with_fallback( "/Users/mineralsteins/Repos/egg_related/upstream_egglog/tests/web-demo/multiset.egg", ); } #[test] - fn test_full_program_python_array_optimize_has_no_todo() { - assert_program_has_no_generic_rule_todo( + fn test_full_program_python_array_optimize_fails_fast_on_unsupported_fallback() { + assert_program_fails_fast_with_fallback( "/Users/mineralsteins/Repos/egg_related/upstream_egglog/tests/python_array_optimize.egg", ); } #[test] - fn test_full_program_tricky_type_checking_has_no_todo() { - assert_program_has_no_generic_rule_todo( + fn test_full_program_tricky_type_checking_fails_fast_on_unsupported_fallback() { + assert_program_fails_fast_with_fallback( "/Users/mineralsteins/Repos/egg_related/upstream_egglog/tests/tricky-type-checking.egg", ); } #[test] - fn test_full_program_web_demo_bignum_has_no_todo() { - assert_program_has_no_generic_rule_todo( + fn test_full_program_web_demo_bignum_fails_fast_on_unsupported_fallback() { + assert_program_fails_fast_with_fallback( "/Users/mineralsteins/Repos/egg_related/upstream_egglog/tests/web-demo/bignum.egg", ); } @@ -5617,8 +5765,8 @@ mod tests { } #[test] - fn test_full_program_web_demo_eqsat_basic_multiset_has_no_todo() { - assert_program_has_no_generic_rule_todo( + fn test_full_program_web_demo_eqsat_basic_multiset_fails_fast_on_unsupported_fallback() { + assert_program_fails_fast_with_fallback( "/Users/mineralsteins/Repos/egg_related/upstream_egglog/tests/web-demo/eqsat-basic-multiset.egg", ); } @@ -5630,8 +5778,8 @@ fn assert_program_has_no_generic_rule_todo(path: &str) { let mut parser = crate::ast::parse::Parser::default(); let commands = parser.get_program_from_string(None, &program).unwrap(); - let rust = EggplantCodeGenerator::new() - .generate_rust(&convert_to_eggplant_with_source(&commands, None)); + let rust = generate_commands_without_fallback(&commands, None) + .unwrap_or_else(|message| panic!("fallback while generating Rust for {path}: {message}")); let line_count = rust.lines().count(); let todo_lines: Vec = rust @@ -5655,6 +5803,90 @@ fn assert_program_has_no_generic_rule_todo(path: &str) { "unexpected TODO lines in generated Rust for {path}:\n{}", todo_lines.join("\n") ); + + let fallback_lines: Vec = rust + .lines() + .enumerate() + .filter(|(_, line)| line.contains(TRANSPILER_FALLBACK_PANIC_PREFIX)) + .map(|(line_index, line)| format!("{:04}: {}", line_index + 1, line)) + .collect(); + assert!( + fallback_lines.is_empty(), + "unexpected fallback lines in generated Rust for {path}:\n{}", + fallback_lines.join("\n") + ); +} + +#[cfg(test)] +fn assert_commands_codegen_fallback_panic( + commands: &[Command], + source_file: Option, + expected_substrings: &[&str], +) -> String { + match generate_commands_without_fallback(commands, source_file) { + Ok(rust) => panic!("expected transpiler fallback panic, generated Rust:\n{rust}"), + Err(message) => { + assert!( + message.contains(TRANSPILER_FALLBACK_PANIC_PREFIX), + "unexpected panic payload: {message}" + ); + assert!( + !message.contains("TODO: implement action for rule_"), + "fallback panic should not expose TODO action code: {message}" + ); + for expected in expected_substrings { + assert!( + message.contains(expected), + "panic payload missing expected substring {expected:?}:\n{message}" + ); + } + message + } + } +} + +#[cfg(test)] +fn assert_program_fails_fast_with_fallback(path: &str) -> String { + let program = std::fs::read_to_string(path).unwrap(); + + let mut parser = crate::ast::parse::Parser::default(); + let commands = parser.get_program_from_string(None, &program).unwrap(); + assert_commands_codegen_fallback_panic(&commands, None, &[]) +} + +#[cfg(test)] +fn generate_commands_without_fallback( + commands: &[Command], + source_file: Option, +) -> Result { + let generated = std::panic::catch_unwind(|| { + EggplantCodeGenerator::new() + .generate_rust(&convert_to_eggplant_with_source(commands, source_file)) + }); + match generated { + Ok(rust) => { + if let Some(fallback_line) = rust + .lines() + .find(|line| line.contains(TRANSPILER_FALLBACK_PANIC_PREFIX)) + { + Err(fallback_line.trim().to_string()) + } else { + Ok(rust) + } + } + Err(payload) => Err(test_panic_payload_to_string(payload)), + } +} + +#[cfg(test)] +fn test_panic_payload_to_string(payload: Box) -> String { + if let Some(message) = payload.downcast_ref::<&str>() { + (*message).to_string() + } else if let Some(message) = payload.downcast_ref::() { + message.clone() + } else { + "panic without string payload".to_string() + } } /// Generate a variable for an expression in condition context @@ -5695,9 +5927,20 @@ fn render_rewrite_condition_handle_expr( format!("{node_name}.handle()") } Expr::Call(_, func_name, args) => { + if !supported_primitive_call(func_name) { + panic!( + "{}: unsupported rewrite condition call {}", + TRANSPILER_FALLBACK_PANIC_PREFIX, func_name + ); + } let output_type = match func_name.as_str() { - "<" | "<=" | ">" | ">=" | "=" | "==" | "!=" => "bool".to_string(), - _ => "i64".to_string(), + "<" | "<=" | ">" | ">=" | "=" | "==" | "!=" | "and" | "or" | "not" => { + "bool".to_string() + } + other => panic!( + "{}: cannot infer rewrite condition primitive result type for {}", + TRANSPILER_FALLBACK_PANIC_PREFIX, other + ), }; let arg_handles = args .iter() @@ -5760,90 +6003,10 @@ fn generate_expression_variable( || is_basic_type(func_name); if !is_known_constructor { - // This is an unknown action/function call - generate function call format - let node_name = format!("node_{}", node_counter); - *node_counter += 1; - - // Extract variables or literal values for arguments - let arg_values: Vec = args - .iter() - .map(|arg| match arg { - Expr::Lit(_, lit) => { - // For literals, use the literal value directly - match lit { - Literal::Int(i) => i.to_string(), - Literal::Float(f) => f.0.to_string(), - Literal::String(s) => format!("\"{}\"", s), - Literal::Bool(b) => b.to_string(), - Literal::Unit => "()".to_string(), - } - } - Expr::Var(_, var_name) => { - // For variables, check if they have constructor context - let normalized_var_name = normalize_identifier(var_name); - if let Some((constructor_name, node_name, arg_index)) = - variable_constructors.get(&normalized_var_name) - { - // This variable has constructor context - generate handle call - let field_name = get_field_name_for_variable_in_constructor( - constructor_name, - *arg_index, - dsl_types, - ); - format!("{}.handle_{}()", node_name, field_name) - } else { - // No constructor context - use the variable name - normalized_var_name - } - } - _ => { - // For other expressions, generate variables - generate_expression_variable( - arg, - dsl_types, - pattern_query_parts, - pattern_vars_variables, - node_counter, - variable_constructors, - ) - } - }) - .collect(); - - // Generate function call query - let query = if arg_values.is_empty() { - format!("let {} = {}::query_leaf();", node_name, func_name) - } else { - // Generate function call with arguments - // For operators like %, use a valid function name - let valid_func_name = format!("TODO_{}", func_name); - let mut query_parts = - vec![format!("let {} = {}::query()", node_name, valid_func_name)]; - - for (i, arg_value) in arg_values.iter().enumerate() { - query_parts.push(format!(".arg_{:02}(&{})", i, arg_value)); - } - - query_parts.push(";".to_string()); - query_parts.join("") - }; - - pattern_query_parts.push(query); - - // For unknown actions, assume return type is i64 (most common for arithmetic operations) - let return_type = "i64".to_string(); - - // Add to pattern variables only if it's a complex type - if !is_basic_type(&return_type) - && !pattern_vars_variables.iter().any(|v| v.name == node_name) - { - pattern_vars_variables.push(PatternVariable { - name: node_name.clone(), - var_type: return_type, - }); - } - - node_name + panic!( + "{}: unsupported expression call {} in pattern query", + TRANSPILER_FALLBACK_PANIC_PREFIX, func_name + ) } else { // This is a known constructor - use the existing logic let node_name = format!("node_{}", node_counter); @@ -5900,19 +6063,25 @@ fn generate_expression_variable( format!("arg_{}_{:02}", variant.fields[i].field_type, i); query_parts.push(format!(".{}(&{})", field_name, arg_value)); } else { - // Fallback if we don't have enough type info - query_parts.push(format!(".arg_{:02}(&{})", i, arg_value)); + panic!( + "{}: constructor {} has no field at argument {}", + TRANSPILER_FALLBACK_PANIC_PREFIX, constructor_name, i + ); } } else { - // Fallback if variant not found - query_parts.push(format!(".arg_{:02}(&{})", i, arg_value)); + panic!( + "{}: cannot find variant {} in DSL type {}", + TRANSPILER_FALLBACK_PANIC_PREFIX, + constructor_name, + dsl_type.name + ); } } } else { - // Fallback if type not found - for (i, arg_value) in arg_values.iter().enumerate() { - query_parts.push(format!(".arg_{:02}(&{})", i, arg_value)); - } + panic!( + "{}: cannot find DSL type for constructor {}", + TRANSPILER_FALLBACK_PANIC_PREFIX, constructor_name + ); } query_parts.push(";".to_string()); diff --git a/examples/action_sample_recorder.rs b/examples/action_sample_recorder.rs index 669117f..c06a453 100644 --- a/examples/action_sample_recorder.rs +++ b/examples/action_sample_recorder.rs @@ -17,17 +17,6 @@ enum RootExpr { tx_rx_vt_pr!(SampleTx, SamplePatRec); -#[eggplant::pat_vars] -struct SamplePatVars { - expr: TraceExpr, -} - -fn sample_pat() -> SamplePatVars { - let expr = TraceExpr::query_leaf(); - let _root = TraceRoot::query(&expr); - SamplePatVars::new(expr) -} - fn describe_event(event: &ActionSampleEvent) -> String { match event { ActionSampleEvent::Insert { @@ -83,7 +72,15 @@ fn main() { SampleTx::add_rule_with_hook( "sample_action_trace_rule", ruleset, - sample_pat, + || { + let expr = TraceExpr::query_leaf(); + let _root = TraceRoot::query(&expr); + #[eggplant::pat_vars] + struct Pat { + expr: TraceExpr, + } + Pat::new(expr) + }, |ctx, pat| { // Once the pattern matches, record the concrete effects produced by the action body. let one = ctx.insert_trace_const(1); diff --git a/examples/constant_prop.rs b/examples/constant_prop.rs index ef2a162..a8fdc7e 100644 --- a/examples/constant_prop.rs +++ b/examples/constant_prop.rs @@ -2,10 +2,20 @@ use eggplant::prelude::*; use eggplant::tx_rx_vt_pr; #[eggplant::dsl] pub enum Expr { + #[typst("{num}")] + #[precedence(100)] Const { num: i64 }, + #[typst("{l} * {r}")] + #[precedence(60)] Mul { l: Expr, r: Expr }, + #[typst("{l} - {r}")] + #[precedence(50)] Sub { l: Expr, r: Expr }, + #[typst("{l} + {r}")] + #[precedence(50)] Add { l: Expr, r: Expr }, + #[typst("frac({l}, {r})")] + #[precedence(60)] Div { l: Expr, r: Expr }, } @@ -40,7 +50,26 @@ fn main() { expr.commit(); let ruleset = MyTx::new_ruleset("constant_prop"); - prop!(Add,+,AddPat,ruleset); + MyTx::add_rule( + stringify!(AddPat), + ruleset, + || { + let l = Const::query(); + let r = Const::query(); + let p = Add::query(&l, &r); + #[eggplant::pat_vars_catch] + struct AddPat { + l: Const, + r: Const, + p: Add, + } + }, + |ctx, pat| { + let cal = ctx.devalue(pat.l.num) + ctx.devalue(pat.r.num); + let op_value = ctx.insert_const(cal); + ctx.union(pat.p, op_value); + }, + ); prop!(Sub,-,SubPat,ruleset); prop!(Mul,*,MulPat,ruleset); prop!(Div,/,DivPat,ruleset); diff --git a/examples/dsl_get.rs b/examples/dsl_get.rs index e7a63d0..83a44e5 100644 --- a/examples/dsl_get.rs +++ b/examples/dsl_get.rs @@ -1,3 +1,4 @@ +use eggplant::egglog; use eggplant::{basic_tx_no_vt, prelude::*}; #[eggplant::dsl] diff --git a/examples/dynamic_action_trace_demo.rs b/examples/dynamic_action_trace_demo.rs index 2538678..72fe903 100644 --- a/examples/dynamic_action_trace_demo.rs +++ b/examples/dynamic_action_trace_demo.rs @@ -18,21 +18,6 @@ enum DemoRoot { tx_rx_vt_pr!(DemoTx, DemoPatRec); -#[eggplant::pat_vars] -struct DemoPatternVars { - l: DemoExpr, - r: DemoExpr, - expr: TraceAdd, -} - -fn demo_pat() -> DemoPatternVars { - let l = DemoExpr::query_leaf(); - let r = DemoExpr::query_leaf(); - let expr = TraceAdd::query(&l, &r); - let _root = DemoRoot::query(&expr); - DemoPatternVars::new(l, r, expr) -} - #[derive(Serialize)] struct NormalizedTrace { version: u32, @@ -84,7 +69,19 @@ fn main() { DemoTx::add_rule_with_hook( "dynamic_action_trace_demo_rule", ruleset, - demo_pat, + || { + let l = DemoExpr::query_leaf(); + let r = DemoExpr::query_leaf(); + let expr = TraceAdd::query(&l, &r); + let _root = DemoRoot::query(&expr); + #[eggplant::pat_vars] + struct Pat { + l: DemoExpr, + r: DemoExpr, + expr: TraceAdd, + } + Pat::new(l, r, expr) + }, move |ctx, pat| { if use_mul { let two = ctx.insert_trace_const(2); diff --git a/examples/fib.rs b/examples/fib.rs index 5dc321f..d8e77a6 100644 --- a/examples/fib.rs +++ b/examples/fib.rs @@ -1,3 +1,4 @@ +use eggplant::egglog; use eggplant::prelude::*; use eggplant::tx_rx_vt_pr; diff --git a/examples/pat_ref.rs b/examples/pat_ref.rs index 0ca7084..fd67bfe 100644 --- a/examples/pat_ref.rs +++ b/examples/pat_ref.rs @@ -23,31 +23,6 @@ enum Expr { }, } tx_rx_vt_pr!(MyTx, MyPatRec); -#[pat_vars] -struct FnamaddPat { - neg_product: NegProdPat, - added: Var, - root: Add, -} -fn fnamadd_pat() -> FnamaddPat { - let neg_product = neg_product_pat(); - let r = Var::query(); - let root = Add::query(&neg_product.neg, &r); - FnamaddPat::new(neg_product, r, root) -} -#[pat_vars] -struct NegProdPat { - neg: Neg, - l: Var, - r: Var, -} -fn neg_product_pat() -> NegProdPat { - let l = Var::query(); - let r = Var::query(); - let product = Mul::query(&l, &r); - let neg = Neg::query(&product); - NegProdPat::new(neg, l, r) -} fn main() { env_logger::init(); @@ -56,11 +31,32 @@ fn main() { &Var::new(5.0), ); let ruleset = MyTx::new_ruleset("intrinsic_recognize"); - MyTx::add_rule("fnamadd rule", ruleset, fnamadd_pat, |ctx, pat| { - println!("Fnamadd values detected {:#?}", pat); - let fnamadd = ctx.insert_fnamadd(pat.neg_product.l, pat.neg_product.r, pat.added); - ctx.union(fnamadd, pat.root); - }); + MyTx::add_rule( + "fnamadd rule", + ruleset, + || { + let l = Var::query(); + let r = Var::query(); + let product = Mul::query(&l, &r); + let neg = Neg::query(&product); + let added = Var::query(); + let root = Add::query(&neg, &added); + #[pat_vars] + struct Pat { + neg: Neg, + l: Var, + r: Var, + added: Var, + root: Add, + } + Pat::new(neg, l, r, added, root) + }, + |ctx, pat| { + println!("Fnamadd values detected {:#?}", pat); + let fnamadd = ctx.insert_fnamadd(pat.l, pat.r, pat.added); + ctx.union(fnamadd, pat.root); + }, + ); expr.commit(); MyTx::run_ruleset(ruleset, RunConfig::Sat); MyTx::egraph_to_dot("egraph.dot"); diff --git a/examples/relation.rs b/examples/relation.rs index 16d86e1..e2155e1 100644 --- a/examples/relation.rs +++ b/examples/relation.rs @@ -1,3 +1,4 @@ +use eggplant::egglog; use eggplant::{prelude::*, tx_rx_vt_pr}; #[eggplant::relation] diff --git a/examples/relation_transfer_story.rs b/examples/relation_transfer_story.rs index 8db53f7..4fc4b8c 100644 --- a/examples/relation_transfer_story.rs +++ b/examples/relation_transfer_story.rs @@ -1,3 +1,4 @@ +use eggplant::egglog; use eggplant::{prelude::*, tx_rx_vt_pr, wrap::EgglogEnumVariantTy}; const ALICE_ID: i64 = 1; @@ -68,15 +69,14 @@ fn main() { "mark_ownership", ruleset, || { - let owns = Owns::query(); let owner = Human::query(); - let same_owner = owns.owner.handle().eq(&owner.handle()); + let owns = Owns::query(&owner); #[eggplant::pat_vars] struct Pat { owns: Owns, owner: Human, } - Pat::new(owns, owner).assert(same_owner) + Pat::new(owns, owner) }, |ctx, pat| { let owner_id = ctx.devalue(pat.owner.id); @@ -88,12 +88,10 @@ fn main() { "apply_transfer", ruleset, || { - let owns = Owns::query(); let current_owner = Human::query(); - let request = TransferRequest::query(); + let owns = Owns::query(¤t_owner); let new_owner = Human::query(); - let same_current_owner = owns.owner.handle().eq(¤t_owner.handle()); - let same_new_owner = request.new_owner.handle().eq(&new_owner.handle()); + let request = TransferRequest::query(&new_owner); let same_item = owns.handle_item_id().eq(&request.handle_item_id()); let owner_changes = current_owner.handle().ne(&new_owner.handle()); #[eggplant::pat_vars] @@ -104,8 +102,6 @@ fn main() { new_owner: Human, } Pat::new(owns, current_owner, request, new_owner) - .assert(same_current_owner) - .assert(same_new_owner) .assert(same_item) .assert(owner_changes) }, @@ -122,20 +118,25 @@ fn main() { let report = OwnershipTx::run_ruleset(ruleset, RunConfig::Sat); println!("matches: {:?}", report.num_matches_per_rule); - println!( - "seed ownership observed (alice, ring): {}", - OwnershipSeen::::get((&ALICE_ID, &RING_ID)) - ); - println!( - "new ownership observed after transfer (bob, ring): {}", - OwnershipSeen::::get((&BOB_ID, &RING_ID)) - ); - println!( - "unrelated ownership untouched (carol, book): {}", - OwnershipSeen::::get((&CAROL_ID, &BOOK_ID)) + let mark_matches = report + .num_matches_per_rule + .get("@mark_ownership") + .copied() + .unwrap_or(0); + let transfer_matches = report + .num_matches_per_rule + .get("@apply_transfer") + .copied() + .unwrap_or(0); + + assert!( + mark_matches >= 3, + "expected at least the seeded ownership facts to be observed" ); - println!( - "transfer applied for ring: {}", - TransferApplied::::get((&RING_ID, &ALICE_ID, &BOB_ID)) + assert_eq!( + transfer_matches, 1, + "expected exactly one transfer application in the story" ); + println!("ownership observations recorded: {mark_matches}"); + println!("transfer applications recorded: {transfer_matches}"); } diff --git a/examples/sample_trace_json.rs b/examples/sample_trace_json.rs index 1bfeac4..250c1d4 100644 --- a/examples/sample_trace_json.rs +++ b/examples/sample_trace_json.rs @@ -16,17 +16,6 @@ enum SampleRoot { tx_rx_vt_pr!(SampleTx, SamplePatRec); -#[eggplant::pat_vars] -struct SamplePatternVars { - expr: SampleExpr, -} - -fn sample_pat() -> SamplePatternVars { - let expr = SampleExpr::query_leaf(); - let _root = SampleRoot::query(&expr); - SamplePatternVars::new(expr) -} - fn main() { let output_path = std::env::args_os() .nth(1) @@ -43,7 +32,15 @@ fn main() { SampleTx::add_rule_with_hook( "sample_trace_json_rule", ruleset, - sample_pat, + || { + let expr = SampleExpr::query_leaf(); + let _root = SampleRoot::query(&expr); + #[eggplant::pat_vars] + struct Pat { + expr: SampleExpr, + } + Pat::new(expr) + }, |ctx, pat| { let one = ctx.insert_trace_const(1); let sum = ctx.insert_trace_add(pat.expr, one); diff --git a/examples/tx_minimal.rs b/examples/tx_minimal.rs index 9590de0..f26305e 100644 --- a/examples/tx_minimal.rs +++ b/examples/tx_minimal.rs @@ -1,4 +1,5 @@ use eggplant::basic_tx_minimal; +use eggplant::egglog; use eggplant::func; use eggplant::prelude::*; diff --git a/examples/tx_rx_vt.rs b/examples/tx_rx_vt.rs index 09051be..aae0b8c 100644 --- a/examples/tx_rx_vt.rs +++ b/examples/tx_rx_vt.rs @@ -1,4 +1,5 @@ use eggplant::basic_tx_rx_vt; +use eggplant::egglog; use eggplant::func; use eggplant::prelude::*; diff --git a/src/test.rs b/src/test.rs index c7840a3..34db7bf 100644 --- a/src/test.rs +++ b/src/test.rs @@ -33,15 +33,15 @@ mod tests { } #[eggplant::dsl] enum DisplayMath { - #[eggplant::display("{x} + {f}")] - #[eggplant::typst("diff({x}, {f})")] - #[eggplant::precedence(5)] + #[display("{x} + {f}")] + #[typst("diff({x}, {f})")] + #[precedence(5)] MDiff { x: DisplayMath, f: DisplayMath, }, - #[eggplant::display("integ {f} {x}")] - #[eggplant::typst("integral({f}, {x})")] + #[display("integ {f} {x}")] + #[typst("integral({f}, {x})")] MIntegral { f: DisplayMath, x: DisplayMath, @@ -52,16 +52,16 @@ mod tests { } #[eggplant::dsl] enum PrecedenceExpr { - #[eggplant::typst("{name}")] + #[typst("{name}")] Var { name: String }, - #[eggplant::typst("{lhs} + {rhs}")] - #[eggplant::precedence(10)] + #[typst("{lhs} + {rhs}")] + #[precedence(10)] Add { lhs: PrecedenceExpr, rhs: PrecedenceExpr, }, - #[eggplant::typst("{lhs} * {rhs}")] - #[eggplant::precedence(20)] + #[typst("{lhs} * {rhs}")] + #[precedence(20)] Mul { lhs: PrecedenceExpr, rhs: PrecedenceExpr, diff --git a/tests/inline_pat_style.rs b/tests/inline_pat_style.rs new file mode 100644 index 0000000..76827b8 --- /dev/null +++ b/tests/inline_pat_style.rs @@ -0,0 +1,25 @@ +#[test] +fn hand_written_benches_and_examples_use_inline_pattern_closures() { + let files = [ + "/Users/mineralsteins/Repos/egg_related/eggplant_backup/examples/action_sample_recorder.rs", + "/Users/mineralsteins/Repos/egg_related/eggplant_backup/examples/sample_trace_json.rs", + "/Users/mineralsteins/Repos/egg_related/eggplant_backup/examples/pat_ref.rs", + "/Users/mineralsteins/Repos/egg_related/eggplant_backup/examples/dynamic_action_trace_demo.rs", + "/Users/mineralsteins/Repos/egg_related/eggplant_backup/benches/runners/eggplant_rewrite/web_demo_unify.rs", + "/Users/mineralsteins/Repos/egg_related/eggplant_backup/benches/runners/eggplant_rewrite/repro_665_set_union.rs", + "/Users/mineralsteins/Repos/egg_related/eggplant_backup/benches/runners/eggplant_rewrite/web_demo_set.rs", + "/Users/mineralsteins/Repos/egg_related/eggplant_backup/benches/runners/eggplant_rewrite/vec_builtins.rs", + ]; + + for path in files { + let source = std::fs::read_to_string(path).expect("source file should be readable"); + assert!( + !source.contains("_pat<"), + "legacy `_pat` helper found in {path}" + ); + assert!( + !source.contains("Pat"), + "legacy top-level Pat struct found in {path}" + ); + } +} From 9f1a08559f0dbfef3cd0bde716777f7e2b683e20 Mon Sep 17 00:00:00 2001 From: MilkBlock <2386925778@qq.com> Date: Wed, 6 May 2026 16:12:38 +0800 Subject: [PATCH 6/8] feat(core): add proof runtime, compat, and extraction backends --- examples/add_rule_proof_smoke.rs | 31 +- examples/constant_prop.egg | 44 + examples/constant_prop_proof.rs | 183 +- examples/constant_prop_sessions.rs | 40 +- examples/constant_prop_sessions_async.rs | 124 +- examples/debug_const_prop_proof_tables.rs | 322 + examples/persisted_snapshot_user_base_hook.rs | 2 +- examples/rustsat_common_subexpr.rs | 175 +- examples/rustsat_optimize_expression.rs | 135 +- rule_svg.png | Bin 0 -> 19624 bytes rules.template | 382141 +++++++++++++++ src/artifact.rs | 17 +- src/instances/mod.rs | 41 + src/instances/session_runtime.rs | 89 +- src/instances/tx_rx_vt_pr.rs | 553 +- .../tx_rx_vt_pr_slot/tx_rx_vt_pr_slot.rs | 34 +- src/lib.rs | 3 + src/prelude.rs | 42 +- src/test.rs | 139 +- src/wrap/compat.rs | 737 + src/wrap/constraint.rs | 41 +- src/wrap/eboost_extract.rs | 449 + src/wrap/mod.rs | 6 + src/wrap/proof_svg.rs | 3420 + src/wrap/rule.rs | 258 +- src/wrap/type_reg.rs | 175 +- src/wrap/wrap.rs | 416 +- tests/eboost_heuristic_extract.rs | 218 + tests/eboost_layered_extract.rs | 184 + tests/extract_typst_svg.rs | 96 + tests/proof_singleton_macro.rs | 11 + tests/schedule_builder.rs | 71 + tests/session_tx_constant_prop.rs | 53 +- tests/tx_sessions.rs | 30 +- tests/typed_extract_cost_model.rs | 1 + tests/typed_lookup_fastpath.rs | 5 +- 36 files changed, 389549 insertions(+), 737 deletions(-) create mode 100644 examples/constant_prop.egg create mode 100644 examples/debug_const_prop_proof_tables.rs create mode 100644 rule_svg.png create mode 100644 rules.template create mode 100644 src/wrap/compat.rs create mode 100644 src/wrap/eboost_extract.rs create mode 100644 src/wrap/proof_svg.rs create mode 100644 tests/eboost_heuristic_extract.rs create mode 100644 tests/eboost_layered_extract.rs create mode 100644 tests/extract_typst_svg.rs create mode 100644 tests/proof_singleton_macro.rs create mode 100644 tests/schedule_builder.rs diff --git a/examples/add_rule_proof_smoke.rs b/examples/add_rule_proof_smoke.rs index 59880be..4e1327e 100644 --- a/examples/add_rule_proof_smoke.rs +++ b/examples/add_rule_proof_smoke.rs @@ -1,35 +1,6 @@ -use egglog::EGraph; use eggplant::prelude::*; -pub struct MyTxProof { - tx: eggplant::instances::tx_rx_vt_pr::TxRxVTPR, -} - -impl SingletonGetter for MyTxProof { - type RetTy = eggplant::instances::tx_rx_vt_pr::TxRxVTPR; - fn sgl() -> &'static eggplant::instances::tx_rx_vt_pr::TxRxVTPR { - static INSTANCE: std::sync::OnceLock = std::sync::OnceLock::new(); - &INSTANCE - .get_or_init(|| MyTxProof { - tx: eggplant::instances::tx_rx_vt_pr::TxRxVTPR::new_with_proof(), - }) - .tx - } -} - -impl eggplant::wrap::NonPatRecSgl for MyTxProof { - fn egraph() -> std::sync::Arc> { - ::egraph() - } -} - -eggplant::basic_patttern_recorder!(MyPatRec); -impl eggplant::wrap::WithPatRecSgl for MyTxProof { - type PatRecSgl = MyPatRec; -} -impl eggplant::wrap::WithRxSgl for MyPatRec { - type RxSgl = MyTxProof; -} +tx_rx_vt_pr_pf!(MyTxProof, MyPatRec); fn main() { let ruleset = MyTxProof::new_ruleset("proof_smoke"); diff --git a/examples/constant_prop.egg b/examples/constant_prop.egg new file mode 100644 index 0000000..679e908 --- /dev/null +++ b/examples/constant_prop.egg @@ -0,0 +1,44 @@ +; Equivalent to `examples/constant_prop.rs`. + +(datatype Expr + (Const i64) + (Mul Expr Expr) + (Sub Expr Expr) + (Add Expr Expr) + (Div Expr Expr)) + +(ruleset constant_prop) + +(rule ((= l (Const x)) + (= r (Const y)) + (= p (Add l r))) + ((union p (Const (+ x y)))) + :ruleset constant_prop + :name "AddPat") + +(rule ((= l (Const x)) + (= r (Const y)) + (= p (Sub l r))) + ((union p (Const (- x y)))) + :ruleset constant_prop + :name "SubPat") + +(rule ((= l (Const x)) + (= r (Const y)) + (= p (Mul l r))) + ((union p (Const (* x y)))) + :ruleset constant_prop + :name "MulPat") + +(rule ((= l (Const x)) + (= r (Const y)) + (= p (Div l r))) + ((union p (Const (/ x y)))) + :ruleset constant_prop + :name "DivPat") + +(let $expr (Add (Mul (Const 3) (Const 2)) (Const 4))) + +(run constant_prop 10) + +(prove (= $expr (Const 10))) diff --git a/examples/constant_prop_proof.rs b/examples/constant_prop_proof.rs index d7a850f..00f48a1 100644 --- a/examples/constant_prop_proof.rs +++ b/examples/constant_prop_proof.rs @@ -1,44 +1,29 @@ -use egglog::EGraph; use eggplant::prelude::*; +use std::{fs, path::Path}; #[eggplant::dsl] pub enum Expr { + #[typst("{name}")] + #[precedence(100)] + Var { name: String }, + #[typst("{num}")] + #[precedence(100)] Const { num: i64 }, + #[typst("{l} * {r}")] + #[precedence(60)] Mul { l: Expr, r: Expr }, + #[typst("{l} - {r}")] + #[precedence(50)] Sub { l: Expr, r: Expr }, + #[typst("{l} + {r}")] + #[precedence(50)] Add { l: Expr, r: Expr }, + #[typst("frac({l}, {r})")] + #[precedence(60)] Div { l: Expr, r: Expr }, } -pub struct MyTxProof { - tx: eggplant::instances::tx_rx_vt_pr::TxRxVTPR, -} - -impl SingletonGetter for MyTxProof { - type RetTy = eggplant::instances::tx_rx_vt_pr::TxRxVTPR; - fn sgl() -> &'static eggplant::instances::tx_rx_vt_pr::TxRxVTPR { - static INSTANCE: std::sync::OnceLock = std::sync::OnceLock::new(); - &INSTANCE - .get_or_init(|| MyTxProof { - tx: eggplant::instances::tx_rx_vt_pr::TxRxVTPR::new_with_proof(), - }) - .tx - } -} - -impl eggplant::wrap::NonPatRecSgl for MyTxProof { - fn egraph() -> std::sync::Arc> { - ::egraph() - } -} - -eggplant::basic_patttern_recorder!(MyPatRec); -impl eggplant::wrap::WithPatRecSgl for MyTxProof { - type PatRecSgl = MyPatRec; -} -impl eggplant::wrap::WithRxSgl for MyPatRec { - type RxSgl = MyTxProof; -} +tx_rx_vt_pr_pf!(MyTxProof, MyPatRec); macro_rules! prop { ($ty:ident,$op:tt,$pat_name:ident,$ruleset:ident) => { @@ -71,8 +56,6 @@ fn main() -> Result<(), egglog::Error> { let mul: Expr = Mul::new(&Const::new(3), &Const::new(2)); let expr: Expr = Add::new(&mul, &Const::new(4)); expr.commit(); - // Capture the *pre-rewrite* value ids so `prove` won't short-circuit on `lhs==rhs` after - // rewrites merge them into the same canonical value. let expr_value = MyTxProof::value(&expr).val; let mul_value = MyTxProof::value(&mul).val; @@ -85,51 +68,161 @@ fn main() -> Result<(), egglog::Error> { let expected_mul_value = MyTxProof::value(&expected_mul).val; let ruleset = MyTxProof::new_ruleset("constant_prop"); - prop!(Add, +, AddPat, ruleset); - prop!(Sub, -, SubPat, ruleset); - prop!(Mul, *, MulPat, ruleset); - prop!(Div, /, DivPat, ruleset); MyTxProof::add_rule( - "AddMulConstPat", + "ConstPropAddPat", ruleset, || { let l = Const::query(); let r = Const::query(); - let m = Mul::query(&l, &r); - let c = Const::query(); - let p = Add::query(&m, &c); + let p = Add::query(&l, &r); #[eggplant::pat_vars_catch] - struct AddMulConstPat { + struct ConstPropAddPat { l: Const, r: Const, - c: Const, p: Add, } }, |ctx, pat| { - let cal = ctx.devalue(pat.l.num) * ctx.devalue(pat.r.num) + ctx.devalue(pat.c.num); + let cal = ctx.devalue(pat.l.num) + ctx.devalue(pat.r.num); + let op_value = ctx.insert_const(cal); + ctx.union(pat.p, op_value); + }, + ); + prop!(Sub, -, SubPat, ruleset); + MyTxProof::add_rule( + "ConstPropMulPat", + ruleset, + || { + let l = Const::query(); + let r = Const::query(); + let p = Mul::query(&l, &r); + #[eggplant::pat_vars_catch] + struct ConstPropMulPat { + l: Const, + r: Const, + p: Mul, + } + }, + |ctx, pat| { + let cal = ctx.devalue(pat.l.num) * ctx.devalue(pat.r.num); let op_value = ctx.insert_const(cal); ctx.union(pat.p, op_value); }, ); + prop!(Div, /, DivPat, ruleset); let report = MyTxProof::run_ruleset(ruleset, RunConfig::Sat); println!("{:#?}", report); assert!( report .num_matches_per_rule - .get("@MulPat") + .get("@ConstPropMulPat") .copied() .unwrap_or(0) > 0, - "MulPat should match in proofs mode" + "ConstPropMulPat should match in proofs mode" ); + let templates = ProofRulesTemplateIndex::from_default_path()?; + let concise = true; + let proof_mul = MyTxProof::sgl().prove_eq_pretty_raw("Expr", mul_value, expected_mul_value)?; println!("{proof_mul}"); + let proof_mul_typst = render_proof_text_typst_with_options(&proof_mul, &templates, concise); + write_typst("target/constant_prop_proof_mul.typ", &proof_mul_typst)?; + let proof_mul_svg = render_proof_text_svg_with_options(&proof_mul, &templates, concise)?; + write_svg("target/constant_prop_proof_mul.svg", &proof_mul_svg)?; + + let proof_mul_value_typst = MyTxProof::sgl().prove_typst_raw_default_template_with_options( + "Expr", + expected_mul_value, + concise, + )?; + write_typst( + "target/constant_prop_proof_mul_value.typ", + &proof_mul_value_typst, + )?; + let proof_mul_value_svg = MyTxProof::sgl().prove_svg_raw_default_template_with_options( + "Expr", + expected_mul_value, + concise, + )?; + write_svg( + "target/constant_prop_proof_mul_value.svg", + &proof_mul_value_svg, + )?; let proof_expr = MyTxProof::sgl().prove_eq_pretty_raw("Expr", expr_value, expected_value)?; println!("{proof_expr}"); + let proof_expr_typst = render_proof_text_typst_with_options(&proof_expr, &templates, concise); + write_typst("target/constant_prop_proof_expr.typ", &proof_expr_typst)?; + let proof_expr_svg = render_proof_text_svg_with_options(&proof_expr, &templates, concise)?; + write_svg("target/constant_prop_proof_expr.svg", &proof_expr_svg)?; + + let add_comm_ruleset = MyTxProof::new_ruleset("add_commutativity"); + MyTxProof::add_rule( + "ConstPropAddCommPat", + add_comm_ruleset, + || { + let a = Expr::query_leaf(); + let b = Expr::query_leaf(); + let p = Add::query(&a, &b); + #[eggplant::pat_vars_catch] + struct ConstPropAddCommPat { + a: Expr, + b: Expr, + p: Add, + } + }, + |ctx, pat| { + let swapped = ctx.insert_add(pat.b, pat.a); + ctx.union(pat.p, swapped); + }, + ); + + let a = Var::::new("a".to_owned()); + let b = Var::::new("b".to_owned()); + let comm_lhs = Add::new(&a, &b); + comm_lhs.commit(); + let comm_rhs = Add::new(&b, &a); + comm_rhs.commit(); + let _ = MyTxProof::run_ruleset(add_comm_ruleset, RunConfig::Sat); + let proof_comm = MyTxProof::sgl().prove_eq_pretty_raw( + "Expr", + MyTxProof::value(&comm_lhs).val, + MyTxProof::value(&comm_rhs).val, + )?; + println!("{proof_comm}"); + let proof_comm_typst = render_proof_text_typst_with_options(&proof_comm, &templates, concise); + write_typst("target/constant_prop_proof_add_comm.typ", &proof_comm_typst)?; + let proof_comm_svg = render_proof_text_svg_with_options(&proof_comm, &templates, concise)?; + write_svg("target/constant_prop_proof_add_comm.svg", &proof_comm_svg)?; println!("constant_prop_proof passed"); Ok(()) } + +fn write_typst(path: impl AsRef, typst: &str) -> Result<(), egglog::Error> { + let path = path.as_ref(); + if let Some(parent) = path.parent() { + fs::create_dir_all(parent).map_err(|err| { + egglog::Error::BackendError(format!("failed to create {}: {err}", parent.display())) + })?; + } + fs::write(path, typst).map_err(|err| { + egglog::Error::BackendError(format!("failed to write {}: {err}", path.display())) + })?; + Ok(()) +} + +fn write_svg(path: impl AsRef, svg: &str) -> Result<(), egglog::Error> { + let path = path.as_ref(); + if let Some(parent) = path.parent() { + fs::create_dir_all(parent).map_err(|err| { + egglog::Error::BackendError(format!("failed to create {}: {err}", parent.display())) + })?; + } + fs::write(path, svg).map_err(|err| { + egglog::Error::BackendError(format!("failed to write {}: {err}", path.display())) + })?; + Ok(()) +} diff --git a/examples/constant_prop_sessions.rs b/examples/constant_prop_sessions.rs index e84d572..3e52ba7 100644 --- a/examples/constant_prop_sessions.rs +++ b/examples/constant_prop_sessions.rs @@ -2,8 +2,14 @@ use eggplant::{prelude::*, tx_rx_vt_pr}; #[eggplant::dsl] pub enum Expr { + #[typst("{num}")] + #[precedence(100)] Const { num: i64 }, + #[typst("{l} * {r}")] + #[precedence(60)] Mul { l: Expr, r: Expr }, + #[typst("{l} + {r}")] + #[precedence(50)] Add { l: Expr, r: Expr }, } @@ -43,36 +49,20 @@ fn register_constant_prop_rules() -> RuleSetId { }) } -fn current_snapshot() -> PersistedSnapshot { +fn current_session_has_const(needle: i64) -> bool { let egraph = MyTx::egraph(); let egraph = egraph.lock().unwrap(); - build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) -} - -fn snapshot_has_const(snapshot: &PersistedSnapshot, needle: i64) -> bool { - let Some(const_decl) = snapshot - .schema - .constructor_decls - .iter() - .find(|decl| decl.name == "Const") - else { - return false; - }; - snapshot.state.function_rows.iter().any(|row| { - row.op_id == const_decl.op_id - && matches!( - row.inputs.first(), - Some(PersistedSnapshotValue::Lit { value, .. }) if value.value == needle.to_string() - ) + egraph.function_rows("Const").into_iter().any(|row| { + !row.subsumed + && row + .vals + .first() + .is_some_and(|value| egraph.value_to_base::(*value) == needle) }) } -fn current_session_has_const(needle: i64) -> bool { - snapshot_has_const(¤t_snapshot(), needle) -} - -fn canonical_eq(lhs: &Expr, rhs_const: i64) -> bool { +fn canonical_eq_const(lhs: &Expr, rhs_const: i64) -> bool { let rhs: Expr = Const::new(rhs_const); rhs.commit(); MyTx::canonical_raw(lhs) == MyTx::canonical_raw(&rhs) @@ -90,7 +80,7 @@ fn fold_mul_add_expr(session: &Session, lhs: i64, rhs: i64, addend: i64) - let _ = MyTx::run_ruleset(ruleset, RunConfig::Sat); let expected = lhs * rhs + addend; - assert!(canonical_eq(&expr, expected)); + assert!(canonical_eq_const(&expr, expected)); expected }) } diff --git a/examples/constant_prop_sessions_async.rs b/examples/constant_prop_sessions_async.rs index 0482047..39e91d5 100644 --- a/examples/constant_prop_sessions_async.rs +++ b/examples/constant_prop_sessions_async.rs @@ -2,8 +2,14 @@ use eggplant::{prelude::*, tx_rx_vt_pr}; #[eggplant::dsl] pub enum Expr { + #[typst("{num}")] + #[precedence(100)] Const { num: i64 }, + #[typst("{l} * {r}")] + #[precedence(60)] Mul { l: Expr, r: Expr }, + #[typst("{l} + {r}")] + #[precedence(50)] Add { l: Expr, r: Expr }, } @@ -43,35 +49,19 @@ fn register_constant_prop_rules() -> RuleSetId { }) } -fn current_snapshot() -> PersistedSnapshot { +fn current_session_has_const(needle: i64) -> bool { let egraph = MyTx::egraph(); let egraph = egraph.lock().unwrap(); - build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) -} -fn snapshot_has_const(snapshot: &PersistedSnapshot, needle: i64) -> bool { - let Some(const_decl) = snapshot - .schema - .constructor_decls - .iter() - .find(|decl| decl.name == "Const") - else { - return false; - }; - - snapshot.state.function_rows.iter().any(|row| { - row.op_id == const_decl.op_id - && matches!( - row.inputs.first(), - Some(PersistedSnapshotValue::Lit { value, .. }) if value.value == needle.to_string() - ) + egraph.function_rows("Const").into_iter().any(|row| { + !row.subsumed + && row + .vals + .first() + .is_some_and(|value| egraph.value_to_base::(*value) == needle) }) } -fn current_session_has_const(needle: i64) -> bool { - snapshot_has_const(¤t_snapshot(), needle) -} - fn canonical_eq(lhs: &Expr, rhs_const: i64) -> bool { let rhs: Expr = Const::new(rhs_const); rhs.commit(); @@ -93,49 +83,57 @@ fn fold_active_mul_add_expr(lhs: i64, rhs: i64, addend: i64) -> i64 { expected } -fn main() { +#[tokio::main(flavor = "multi_thread", worker_threads = 2)] +async fn main() { env_logger::init(); - let runtime = tokio::runtime::Builder::new_multi_thread() - .worker_threads(2) - .enable_all() - .build() - .unwrap(); - - runtime.block_on(async { - let left = MyTx::new_session(); - let right = MyTx::new_session(); - - let left_value = left - .run_async(async { - tokio::task::yield_now().await; - fold_active_mul_add_expr(3, 2, 4) - }) - .await; - assert_eq!(left_value, 10); - - let right_join = right.spawn_async(async { + let left = MyTx::new_session(); + let right = MyTx::new_session(); + + let left_value = left + .run_async(async { tokio::task::yield_now().await; - fold_active_mul_add_expr(5, 5, 1) - }); - assert_eq!(right_join.await.unwrap(), 26); - - assert!(left.run_async(async { current_session_has_const(10) }).await); - assert!(!left.run_async(async { current_session_has_const(26) }).await); - assert!(right.run_async(async { current_session_has_const(26) }).await); - assert!(!right.run_async(async { current_session_has_const(10) }).await); - - let outer = MyTx::new_session(); - let inner = MyTx::new_session(); - outer - .run_async(async { - tokio::task::yield_now().await; - let inner_value = inner.run(|| fold_active_mul_add_expr(5, 5, 1)); - assert_eq!(inner_value, 26); - assert!(inner.run(|| current_session_has_const(26))); - assert!(!outer.run(|| current_session_has_const(26))); - }) - .await; + fold_active_mul_add_expr(3, 2, 4) + }) + .await; + assert_eq!(left_value, 10); + + let right_join = right.spawn_async(async { + tokio::task::yield_now().await; + fold_active_mul_add_expr(5, 5, 1) }); + assert_eq!(right_join.await.unwrap(), 26); + + assert!( + left.run_async(async { current_session_has_const(10) }) + .await + ); + assert!( + !left + .run_async(async { current_session_has_const(26) }) + .await + ); + assert!( + right + .run_async(async { current_session_has_const(26) }) + .await + ); + assert!( + !right + .run_async(async { current_session_has_const(10) }) + .await + ); + + let outer = MyTx::new_session(); + let inner = MyTx::new_session(); + outer + .run_async(async { + tokio::task::yield_now().await; + let inner_value = inner.run(|| fold_active_mul_add_expr(5, 5, 1)); + assert_eq!(inner_value, 26); + assert!(inner.run(|| current_session_has_const(26))); + assert!(!outer.run(|| current_session_has_const(26))); + }) + .await; println!("constant_prop_sessions_async passed"); } diff --git a/examples/debug_const_prop_proof_tables.rs b/examples/debug_const_prop_proof_tables.rs new file mode 100644 index 0000000..d21c08a --- /dev/null +++ b/examples/debug_const_prop_proof_tables.rs @@ -0,0 +1,322 @@ +use egglog::{ArcSort, EGraph, Error, Value}; +use eggplant::prelude::*; +use std::collections::BTreeSet; +use std::fmt::Write as _; +use std::fs; +use std::path::Path; + +#[eggplant::dsl] +pub enum Expr { + #[typst("{num}")] + #[precedence(100)] + Const { num: i64 }, + #[typst("{l} * {r}")] + #[precedence(60)] + Mul { l: Expr, r: Expr }, + #[typst("{l} - {r}")] + #[precedence(50)] + Sub { l: Expr, r: Expr }, + #[typst("{l} + {r}")] + #[precedence(50)] + Add { l: Expr, r: Expr }, + #[typst("frac({l}, {r})")] + #[precedence(60)] + Div { l: Expr, r: Expr }, +} + +tx_rx_vt_pr_pf!(DebugTxProof, DebugPatRec); + +macro_rules! prop { + ($ty:ident,$op:tt,$pat_name:ident,$ruleset:ident) => { + DebugTxProof::add_rule( + stringify!($pat_name), + $ruleset, + || { + let l = Const::query(); + let r = Const::query(); + let p = $ty::query(&l, &r); + #[eggplant::pat_vars_catch] + struct $pat_name { + l: Const, + r: Const, + p: $ty, + } + }, + |ctx, pat| { + let cal = ctx.devalue(pat.l.num) $op ctx.devalue(pat.r.num); + let op_value = ctx.insert_const(cal); + ctx.union(pat.p, op_value); + }, + ); + }; +} + +fn main() -> Result<(), Error> { + let mut egg = EGraph::new_with_proofs(); + egg.parse_and_run_program(Some("debug_const_prop_egg".to_owned()), egg_program())?; + dump_egraph("egg", &egg, "target/debug_const_prop_tables_egg.txt")?; + + run_rust_api_program()?; + let egraph = DebugTxProof::sgl().egraph.lock().unwrap(); + dump_egraph( + "rust-api", + &egraph, + "target/debug_const_prop_tables_rust.txt", + )?; + + Ok(()) +} + +fn egg_program() -> &'static str { + r#" +(datatype Expr + (Const i64) + (Mul Expr Expr) + (Sub Expr Expr) + (Add Expr Expr) + (Div Expr Expr)) + +(ruleset constant_prop) + +(rule ((= l (Const x)) + (= r (Const y)) + (= p (Add l r))) + ((union p (Const (+ x y)))) + :ruleset constant_prop + :name "AddPat") + +(rule ((= l (Const x)) + (= r (Const y)) + (= p (Sub l r))) + ((union p (Const (- x y)))) + :ruleset constant_prop + :name "SubPat") + +(rule ((= l (Const x)) + (= r (Const y)) + (= p (Mul l r))) + ((union p (Const (* x y)))) + :ruleset constant_prop + :name "MulPat") + +(rule ((= l (Const x)) + (= r (Const y)) + (= p (Div l r))) + ((union p (Const (/ x y)))) + :ruleset constant_prop + :name "DivPat") + +(rule ((= l (Const x)) + (= r (Const y)) + (= m (Mul l r)) + (= c (Const z)) + (= p (Add m c))) + ((union p (Const (+ (* x y) z)))) + :ruleset constant_prop + :name "AddMulConstPat") + +(let $mul (Mul (Const 3) (Const 2))) +(let $expr (Add $mul (Const 4))) +(let $expected (Const 10)) +(let $expected_mul (Const 6)) + +(run constant_prop 10) +"# +} + +fn run_rust_api_program() -> Result<(), Error> { + let mul: Expr = Mul::new(&Const::new(3), &Const::new(2)); + let expr: Expr = Add::new(&mul, &Const::new(4)); + expr.commit(); + + let expected: Expr = Const::new(10); + expected.commit(); + + let expected_mul: Expr = Const::new(6); + expected_mul.commit(); + + { + let egraph = DebugTxProof::sgl().egraph.lock().unwrap(); + dump_egraph( + "rust-api-after-commits", + &egraph, + "target/debug_const_prop_tables_rust_after_commits.txt", + )?; + } + + let ruleset = DebugTxProof::new_ruleset("constant_prop"); + DebugTxProof::add_rule( + "DebugConstPropAddPat", + ruleset, + || { + let l = Const::query(); + let r = Const::query(); + let p = Add::query(&l, &r); + #[eggplant::pat_vars_catch] + struct DebugConstPropAddPat { + l: Const, + r: Const, + p: Add, + } + }, + |ctx, pat| { + let cal = ctx.devalue(pat.l.num) + ctx.devalue(pat.r.num); + let op_value = ctx.insert_const(cal); + ctx.union(pat.p, op_value); + }, + ); + prop!(Sub, -, SubPat, ruleset); + DebugTxProof::add_rule( + "DebugConstPropMulPat", + ruleset, + || { + let l = Const::query(); + let r = Const::query(); + let p = Mul::query(&l, &r); + #[eggplant::pat_vars_catch] + struct DebugConstPropMulPat { + l: Const, + r: Const, + p: Mul, + } + }, + |ctx, pat| { + let cal = ctx.devalue(pat.l.num) * ctx.devalue(pat.r.num); + let op_value = ctx.insert_const(cal); + ctx.union(pat.p, op_value); + }, + ); + prop!(Div, /, DivPat, ruleset); + + { + let egraph = DebugTxProof::sgl().egraph.lock().unwrap(); + dump_egraph( + "rust-api-after-rules", + &egraph, + "target/debug_const_prop_tables_rust_after_rules.txt", + )?; + } + + let _ = DebugTxProof::run_ruleset(ruleset, RunConfig::Sat); + Ok(()) +} + +fn dump_egraph(label: &str, egraph: &EGraph, path: impl AsRef) -> Result<(), Error> { + let mut out = String::new(); + writeln!(out, "label: {label}").unwrap(); + + let mut selected = BTreeSet::new(); + for logical_name in ["Const", "Mul", "Add", "Sub", "Div"] { + selected.insert(logical_name.to_owned()); + if let Ok(view_name) = egraph.proof_view_name(logical_name) { + selected.insert(view_name); + } + } + if let Ok(uf_name) = egraph.uf_proof_name("Expr") { + selected.insert(uf_name); + } + + let mut all_names = egraph.get_function_names(); + all_names.sort(); + for name in all_names { + let Some(function) = egraph.get_function(&name) else { + continue; + }; + let schema = function.schema(); + let output_sort = schema.output.name(); + let input_has_interesting_sort = schema.input.iter().any(|sort| { + let sort_name = sort.name(); + sort_name.contains("Expr") + || sort_name.contains("Proof") + || sort_name.contains("Ast") + || sort_name.contains("UFPair") + }); + let name_interesting = [ + "Expr", "Const", "Mul", "Add", "Sub", "Div", "Proof", "UF", "View", "Fiat", "Rule", + "Merge", "Trans", "Sym", "Congr", "PCons", "PNil", "commit", + ] + .iter() + .any(|needle| name.contains(needle)); + + if name_interesting + || input_has_interesting_sort + || output_sort.contains("Expr") + || output_sort.contains("Proof") + || output_sort.contains("Ast") + || output_sort.contains("UFPair") + { + selected.insert(name); + } + } + + for name in selected { + let Some(function) = egraph.get_function(&name) else { + continue; + }; + let schema = function.schema(); + let input_sorts = schema + .input + .iter() + .map(|sort| sort.name().to_owned()) + .collect::>(); + let output_sort = schema.output.name().to_owned(); + let mut rows = Vec::new(); + egraph.function_for_each(&name, |row| { + rows.push((row.vals.to_vec(), row.subsumed)); + })?; + if rows.is_empty() { + continue; + } + + writeln!( + out, + "\n## {name}\ninputs: ({}) -> {output_sort}\nrows: {}", + input_sorts.join(" "), + rows.len() + ) + .unwrap(); + + for (idx, (vals, subsumed)) in rows.iter().take(200).enumerate() { + let mut formatted = Vec::new(); + for (pos, value) in vals.iter().enumerate() { + if let Some(sort) = schema.get_by_pos(pos) { + formatted.push(format_value(egraph, *value, sort)); + } else { + formatted.push(format!("{value:?}:")); + } + } + writeln!( + out, + " [{idx:03}] {}{}", + formatted.join(", "), + if *subsumed { " ; subsumed" } else { "" } + ) + .unwrap(); + } + if rows.len() > 200 { + writeln!(out, " ... {} more rows", rows.len() - 200).unwrap(); + } + } + + let path = path.as_ref(); + if let Some(parent) = path.parent() { + fs::create_dir_all(parent).map_err(|err| { + Error::BackendError(format!("failed to create {}: {err}", parent.display())) + })?; + } + fs::write(path, out) + .map_err(|err| Error::BackendError(format!("failed to write {}: {err}", path.display())))?; + Ok(()) +} + +fn format_value(egraph: &EGraph, value: Value, sort: &ArcSort) -> String { + let sort_name = sort.name(); + let rendered = match sort_name { + "i64" => egraph.value_to_base::(value).to_string(), + "bool" => egraph.value_to_base::(value).to_string(), + "String" => format!("{:?}", egraph.value_to_base::(value)), + "Unit" | "()" => "()".to_owned(), + _ => format!("{value:?}"), + }; + format!("{rendered}:{sort_name}") +} diff --git a/examples/persisted_snapshot_user_base_hook.rs b/examples/persisted_snapshot_user_base_hook.rs index a7080aa..0f60e4d 100644 --- a/examples/persisted_snapshot_user_base_hook.rs +++ b/examples/persisted_snapshot_user_base_hook.rs @@ -34,7 +34,7 @@ fn main() { ) .unwrap(); - eggplant::egglog::prelude::run_ephemeral_rust_rule( + run_ephemeral_rust_rule( &mut egraph, "seed_demo_user_base_snapshot", &[], diff --git a/examples/rustsat_common_subexpr.rs b/examples/rustsat_common_subexpr.rs index af7548c..ce2661e 100644 --- a/examples/rustsat_common_subexpr.rs +++ b/examples/rustsat_common_subexpr.rs @@ -1,92 +1,105 @@ -use eggplant::{prelude::*, tx_rx_vt_pr}; - -#[eggplant::dsl] -enum CseExpr { - CLeaf { n: i64 }, - CInc { inner: CseExpr }, - CPair { lhs: CseExpr, rhs: CseExpr }, +#[cfg(not(feature = "rustsat-extract"))] +fn main() { + eprintln!("rustsat_common_subexpr requires --features rustsat-extract"); } -tx_rx_vt_pr!(RustsatCseTx, RustsatCsePatRec); +#[cfg(feature = "rustsat-extract")] +mod real { + use eggplant::{prelude::*, tx_rx_vt_pr}; -fn main() { - let _ = env_logger::try_init(); - RustsatCseTx::reset_for_bench(); + #[eggplant::dsl] + enum CseExpr { + CLeaf { n: i64 }, + CInc { inner: CseExpr }, + CPair { lhs: CseExpr, rhs: CseExpr }, + } + + tx_rx_vt_pr!(RustsatCseTx, RustsatCsePatRec); - let shared_leaf = CLeaf::::new(0); - let shared_l1 = CInc::::new(&shared_leaf); - let shared = CInc::::new(&shared_l1); - let shared_root = CPair::::new(&shared, &shared); - shared_root.commit(); + pub fn main() { + let _ = env_logger::try_init(); + RustsatCseTx::reset_for_bench(); - let left_leaf = CLeaf::::new(1); - let right_leaf = CLeaf::::new(2); - let left = CInc::::new(&left_leaf); - let right = CInc::::new(&right_leaf); - let duplicated_root = CPair::::new(&left, &right); - duplicated_root.commit(); + let shared_leaf = CLeaf::::new(0); + let shared_l1 = CInc::::new(&shared_leaf); + let shared = CInc::::new(&shared_l1); + let shared_root = CPair::::new(&shared, &shared); + shared_root.commit(); - let ruleset = RustsatCseTx::new_ruleset("union_common_subexpr_roots_for_rustsat_demo"); - RustsatCseTx::add_rule( - "union_common_subexpr_roots_for_rustsat_demo", - ruleset, - || { - let shared_leaf = CLeaf::query(); - let shared_l1 = CInc::query(&shared_leaf); - let shared = CInc::query(&shared_l1); - let shared_root = CPair::query(&shared, &shared); + let left_leaf = CLeaf::::new(1); + let right_leaf = CLeaf::::new(2); + let left = CInc::::new(&left_leaf); + let right = CInc::::new(&right_leaf); + let duplicated_root = CPair::::new(&left, &right); + duplicated_root.commit(); - let left_leaf = CLeaf::query(); - let left = CInc::query(&left_leaf); - let right_leaf = CLeaf::query(); - let right = CInc::query(&right_leaf); - let duplicated_root = CPair::query(&left, &right); - #[eggplant::pat_vars_catch] - struct Pat { - shared_leaf: CLeaf, - shared_root: CPair, - left_leaf: CLeaf, - right_leaf: CLeaf, - duplicated_root: CPair, - } - }, - |ctx, pat| { - let shared_n = ctx.devalue(pat.shared_leaf.n); - let left_n = ctx.devalue(pat.left_leaf.n); - let right_n = ctx.devalue(pat.right_leaf.n); - if shared_n == 0 && left_n == 1 && right_n == 2 { - ctx.union(pat.shared_root, pat.duplicated_root); - } - }, - ); - RustsatCseTx::run_ruleset(ruleset, RunConfig::Once); + let ruleset = RustsatCseTx::new_ruleset("union_common_subexpr_roots_for_rustsat_demo"); + RustsatCseTx::add_rule( + "union_common_subexpr_roots_for_rustsat_demo", + ruleset, + || { + let shared_leaf = CLeaf::query(); + let shared_l1 = CInc::query(&shared_leaf); + let shared = CInc::query(&shared_l1); + let shared_root = CPair::query(&shared, &shared); - let (legacy_rendered, legacy_cost) = RustsatCseTx::extract_node_to_string(&shared_root) - .expect("legacy extraction should succeed"); - let (rustsat_rendered, rustsat_cost) = RustsatCseTx::extract_node_to_string_with_backend( - &shared_root, - ExtractBackend::::rustsat( - RustsatExtractConfig::default(), - ), - ) - .expect("rustsat extraction should succeed on the common-subexpression demo"); + let left_leaf = CLeaf::query(); + let left = CInc::query(&left_leaf); + let right_leaf = CLeaf::query(); + let right = CInc::query(&right_leaf); + let duplicated_root = CPair::query(&left, &right); + #[eggplant::pat_vars_catch] + struct Pat { + shared_leaf: CLeaf, + shared_root: CPair, + left_leaf: CLeaf, + right_leaf: CLeaf, + duplicated_root: CPair, + } + }, + |ctx, pat| { + let shared_n = ctx.devalue(pat.shared_leaf.n); + let left_n = ctx.devalue(pat.left_leaf.n); + let right_n = ctx.devalue(pat.right_leaf.n); + if shared_n == 0 && left_n == 1 && right_n == 2 { + ctx.union(pat.shared_root, pat.duplicated_root); + } + }, + ); + RustsatCseTx::run_ruleset(ruleset, RunConfig::Once); - println!("legacy extracted term: {legacy_rendered}"); - println!("legacy extracted cost: {legacy_cost}"); - println!("rustsat extracted term: {rustsat_rendered}"); - println!("rustsat extracted cost: {rustsat_cost}"); + let (legacy_rendered, legacy_cost) = RustsatCseTx::extract_node_to_string(&shared_root) + .expect("legacy extraction should succeed"); + let (rustsat_rendered, rustsat_cost) = RustsatCseTx::extract_node_to_string_with_backend( + &shared_root, + ExtractBackend::::rustsat( + RustsatExtractConfig::default(), + ), + ) + .expect("rustsat extraction should succeed on the common-subexpression demo"); - assert!( - legacy_rendered.contains("(CInc (CLeaf 1))") - && legacy_rendered.contains("(CInc (CLeaf 2))"), - "legacy tree-additive extraction should prefer the duplicated non-shared expression because it over-counts the shared subtree" - ); - assert!( - rustsat_rendered.contains("(CInc (CInc (CLeaf 0)))"), - "rustsat backend should prefer the shared-subexpression variant" - ); - assert!( - legacy_cost > rustsat_cost, - "the demo should show a strictly smaller weighted-MaxSAT/DAG cost than the legacy tree-additive cost" - ); + println!("legacy extracted term: {legacy_rendered}"); + println!("legacy extracted cost: {legacy_cost}"); + println!("rustsat extracted term: {rustsat_rendered}"); + println!("rustsat extracted cost: {rustsat_cost}"); + + assert!( + legacy_rendered.contains("(CInc (CLeaf 1))") + && legacy_rendered.contains("(CInc (CLeaf 2))"), + "legacy tree-additive extraction should prefer the duplicated non-shared expression because it over-counts the shared subtree" + ); + assert!( + rustsat_rendered.contains("(CInc (CInc (CLeaf 0)))"), + "rustsat backend should prefer the shared-subexpression variant" + ); + assert!( + legacy_cost > rustsat_cost, + "the demo should show a strictly smaller weighted-MaxSAT/DAG cost than the legacy tree-additive cost" + ); + } +} + +#[cfg(feature = "rustsat-extract")] +fn main() { + real::main(); } diff --git a/examples/rustsat_optimize_expression.rs b/examples/rustsat_optimize_expression.rs index ba38886..4e180bb 100644 --- a/examples/rustsat_optimize_expression.rs +++ b/examples/rustsat_optimize_expression.rs @@ -1,70 +1,83 @@ -use eggplant::{prelude::*, tx_rx_vt_pr}; - -#[eggplant::dsl] -enum RustsatExpr { - Leaf { - n: i64, - }, - #[cost(0)] - CheapWrap { - inner: RustsatExpr, - }, - #[cost(5)] - ExpensiveWrap { - inner: RustsatExpr, - }, -} - -tx_rx_vt_pr!(RustsatDemoTx, RustsatDemoPatRec); - +#[cfg(not(feature = "rustsat-extract"))] fn main() { - let _ = env_logger::try_init(); - RustsatDemoTx::reset_for_bench(); + eprintln!("rustsat_optimize_expression requires --features rustsat-extract"); +} - let leaf = Leaf::::new(7); - let cheap = CheapWrap::::new(&leaf); - cheap.commit(); - let expensive = ExpensiveWrap::::new(&leaf); - expensive.commit(); +#[cfg(feature = "rustsat-extract")] +mod real { + use eggplant::{prelude::*, tx_rx_vt_pr}; - let ruleset = RustsatDemoTx::new_ruleset("union_wrapper_variants_for_rustsat_demo"); - RustsatDemoTx::add_rule( - "union_wrapper_variants_for_rustsat_demo", - ruleset, - || { - let leaf = Leaf::query(); - let cheap = CheapWrap::query(&leaf); - let expensive = ExpensiveWrap::query(&leaf); - #[eggplant::pat_vars_catch] - struct Pat { - cheap: CheapWrap, - expensive: ExpensiveWrap, - } + #[eggplant::dsl] + enum RustsatExpr { + Leaf { + n: i64, + }, + #[cost(0)] + CheapWrap { + inner: RustsatExpr, }, - |ctx, pat| { - ctx.union(pat.cheap, pat.expensive); + #[cost(5)] + ExpensiveWrap { + inner: RustsatExpr, }, - ); - RustsatDemoTx::run_ruleset(ruleset, RunConfig::Once); + } + + tx_rx_vt_pr!(RustsatDemoTx, RustsatDemoPatRec); - let (legacy_rendered, legacy_cost) = - RustsatDemoTx::extract_node_to_string(&cheap).expect("legacy extraction should succeed"); - let (rustsat_rendered, rustsat_cost) = RustsatDemoTx::extract_node_to_string_with_backend( - &cheap, - ExtractBackend::::rustsat( - RustsatExtractConfig::default(), - ), - ) - .expect("rustsat extraction should succeed on the acyclic wrapper demo"); + pub fn main() { + let _ = env_logger::try_init(); + RustsatDemoTx::reset_for_bench(); - println!("legacy extracted term: {legacy_rendered}"); - println!("legacy extracted cost: {legacy_cost}"); - println!("rustsat extracted term: {rustsat_rendered}"); - println!("rustsat extracted cost: {rustsat_cost}"); + let leaf = Leaf::::new(7); + let cheap = CheapWrap::::new(&leaf); + cheap.commit(); + let expensive = ExpensiveWrap::::new(&leaf); + expensive.commit(); - assert!( - rustsat_rendered.contains("CheapWrap"), - "rustsat backend should pick the lower-cost wrapper" - ); - assert_eq!(rustsat_cost, 1); + let ruleset = RustsatDemoTx::new_ruleset("union_wrapper_variants_for_rustsat_demo"); + RustsatDemoTx::add_rule( + "union_wrapper_variants_for_rustsat_demo", + ruleset, + || { + let leaf = Leaf::query(); + let cheap = CheapWrap::query(&leaf); + let expensive = ExpensiveWrap::query(&leaf); + #[eggplant::pat_vars_catch] + struct Pat { + cheap: CheapWrap, + expensive: ExpensiveWrap, + } + }, + |ctx, pat| { + ctx.union(pat.cheap, pat.expensive); + }, + ); + RustsatDemoTx::run_ruleset(ruleset, RunConfig::Once); + + let (legacy_rendered, legacy_cost) = RustsatDemoTx::extract_node_to_string(&cheap) + .expect("legacy extraction should succeed"); + let (rustsat_rendered, rustsat_cost) = RustsatDemoTx::extract_node_to_string_with_backend( + &cheap, + ExtractBackend::::rustsat( + RustsatExtractConfig::default(), + ), + ) + .expect("rustsat extraction should succeed on the acyclic wrapper demo"); + + println!("legacy extracted term: {legacy_rendered}"); + println!("legacy extracted cost: {legacy_cost}"); + println!("rustsat extracted term: {rustsat_rendered}"); + println!("rustsat extracted cost: {rustsat_cost}"); + + assert!( + rustsat_rendered.contains("CheapWrap"), + "rustsat backend should pick the lower-cost wrapper" + ); + assert_eq!(rustsat_cost, 1); + } +} + +#[cfg(feature = "rustsat-extract")] +fn main() { + real::main(); } diff --git a/rule_svg.png b/rule_svg.png new file mode 100644 index 0000000000000000000000000000000000000000..95791cf1888f5cf2700a92d2b510197174e04fbf GIT binary patch literal 19624 zcmbq*Wmr^Q)b@aa2qN7bf`EW@&nQTjf`GKrozkr!NOz~S#L(T{-QC?aLk-`-=X-y> zKi_@f1?QZ-_t~-bTK8J(KK}lwAc=`iiVgySFr}qFD1ksv%s?O{d^BX>&Ll#q1Nima zMoQft1j4|3{D%ZeOeO|_s6o;n-hXyZK3sHi$Gd!ZcA_X~GN+Wti=wfE+Ly{{P-V#U z^7DtMvuL!kC@>3_!1N#U(4T1mc=#v=f$ucKH@^-O){zj7y_a_CJq}a6U3HaabBgOX zxp4*G?9j=xIi=NWu^+p6#WK?i{{n^p@=nP^;|OrG@L!IO@2+;9*{XTG%Wc3c`r<=2 zE$Yv|N2TvK^ke!y-l}qhk*!$2YL~QThbp89RhdsSFw-`u6sW#`ukm0sIAKYV`X4`k{`}=Ly@30{{B{+|IK$=65~k0;M|AWVhncy#-9H4vLMT0)yd^S6O)S)z z9|vTkq}SeEtStnoH+e5t??}_y%FBlP_<*1N)9Si*rUV#v5hW$~xWnF?C$?i9wp_W2 z;s?!>mMLK^A6K3jra|BckqgzD$S<9tE!%Ixmsd{;LLHG)|(OPWpakW9dlfS}#KEr(X-_@JHm{ius z)7_)5{!IY2B?NozaC5R;l5axm2~gWx+{!l`5FWugK-58?k+;s+qH~qzKYu;Gi@Go; zXR9lO>_*8$UEM`oTwKLa#X){>Fo};sn~mBRn~#qV%gJe&Ayr35XKBeymufjjKB=z0 zeqK+L(l6zE3low&H+w{P!1+1g6?Vp362i3WsKSM$CNZ`wONT;D-PrtyuA zi5YvAooz_48RO^InVp^O=_${HKp-Lc=;+AfFT_5h$pYjWz4&p4T4J`gwus3Baq&(t z82o;&1rVavKjV5-m>%h`e6jzG@Amce*`F(za3fd~`Cu@Zn!)36(y5Cyic}38fF4$m z1A~Itb!(NB?C7KlEUEC;chT#oQ@h_ycen5F5`R5?rb+d|6wS5Z+(iAqxb_>nkkvMTWXeOAzjS>>C67cX9*VPU{7F2Wmm z`9uRWiX^UpVYeWvju#sB)$G1~qq#r7t%M9GpKs)_&XcR8w*C3D&Ztn6zcAO`G15U$ zgIlCJ4`%3+-*mj|_}%u0c6R@i+P9`QAD@*B7)Jo-W`sWrGjrmk%9B(<53BaAA{?9y z*pf&e!mrl(bS%3+uDxA!v}Lq%l=fN`s-s9^3)3$ZzV^uIdXtw+E%)n2`N)xP#?VXA=9!)SQP-oBdpRfB#uQ34uLD+Dj?aIh9r1(DD<>QKwH7mkyau3+U zQ+=w7lMA@}=3g&5nU#?D=HydB{JfXhbu7MudZr~ zQLTKsk18rL2{D_yt0aV^eel9zI>a#u5u)Nj6dzd}V9L^w(o5H)B`G~ucNr78PlfFc_(Ldi z704gDw{)wDbkApk^L@h^(_BpVuPA)OSH<+7)AZ(hja93usEyA=VB76Ly>@^8^hYrG zUhI2le*FrXA1NcCsvI%f9!do7M)=pDm@GA1Pw9F!Y!5~FhL^&Y>o2FNo?SJkV3*lV z@^L$A-SwTjIa=K8&c~eoe73d!o$iRjZTHM@-$__V=vk>gUGAirh=_1`xqU}7%Iu>? z6h)i8>&L2w9g0ykN7ndab9#)yot8A@(ssvhtM>l(L7VPR_m8I*9JYIETAw_pAp#Dn z^QqqcRFPt;aOYI{@yhagw}=$lZ2d8a#$e-w|48-D-Q!`QF@)@+l6)ff?tCun*Wmnf znj%gAi^K6GY^9GM;a6u^&uMhs&z9mxVc4RA4hL^nt~{MWJ$E(|%J-)pt~wTGrw-0K zgW~%7`ac+V9enJV-W>myC07>T<>x5#g9k8vBD{8VN2 zC1r|K!Y>Z$BUUq{7IgOmDc92;3nf^pJp@~Wl9$lV7q~J>mBH`b8>2S zzLvo#sv%}NX9&!Uc-)sw-G}{v)p>_68wc}4uuLyPjJ|OyYu@GSQ3Al=`?ls-P#>UoD z)TimabT%$-x4>V(b;a*cLLJ=41Nu&chNktRwfWXj+}A%zvruiA(zB^)n~T%wP=Ues zMNpW7y*-(5$;02{sRJQ6Y%qxj5b@KWgN@q3szst`G(}=R!YJo5m6&+DB>|K1{ymLR z8LGZU(Uq2lMtId1XB~?Q55R`zF>=!W081&%_In_DM)jQ_ZxIouVWSX0Y=3ojXd$*Vdk2>|syVmvv5k8YXp` z>`*4BzAA*Px?T4XtQuOxcq|~giz$SnX44P|&*$tS&;tgAG=X|Vby2O03rWJPpPwIK zMyVRB3yon`eO4%PH_O{B<6LFFakfs%*XDOWE9NK{>n`?28>OQd`eIk1%@6A3R!?rr zjl+tg7=;TD7(nT^WANK$9y|CHg^(9~ce+&nDED$syt9-2Rl_N4HFLc?^qcGwhw!7# zU>r_<1swW$f9$b8F6S=~=ThY%ifAO9C0<+*h;)*plQNDd;`W&I-hSoqUc;pFT5xgi z*h?ew0=?*&qO78#vxn(#9f(VtSnQOsD6qQHy&U2L<`zhF76eDW-zY z2eHg&(^xAs4BNYhACC9q@Rm13TrxL){YU~KdC?!wmLGe=H#PmALhml_0TiQL@&Z_l z1^dE3e~)w*gtPI(lVIm6jJ!Qc^ONQKTuG zf{vB^AzU@d>+qwUa&m1#khiOeOc>FQufN~n za--!C-Y~h4%U-|A@(ANC?691EcQbtDYtYmq zC}sHn1d?&qsKKoK!zdJ&>aEY{)~)s@?Jq=}?spFFXBzyxsK9-KBf@tp_d&XDz3pOl zHmaXKsek@l__d(BA&5vrde>s$sy?EK;EN%VVYS!-I z$dZ>OLVx6`fw*{fT-zOVDYp|RH8fOjboYu>St>uhHFlEOL;QTe7VQeHt^PUbga%+ipk-@v(yL-% z0$bV*J@@4fQYXm?<3D~>Sgd`r(FjWQa#%jH%o_rEqqZ(CHd-d_R9U`xq4(!ajEs2h zz}DH>+1^~X{WM!jk(SFR+fp?=b`~{JkGt7E0xFL_g!{@;eZAw}NU?TOSy@?O^1`u~ zR$NM)B-(638RNIpvFc^H&jy)QTScm{y`>n~27sF@Fi0*+PYb%JVl&A_JogH$n;CsC zj-8S&SM|erOG@&3vfH}v?g|zlY1$QE$KbZ1EHA@R!iMFXYjx&Tf3|-7__4;ee`;Gt zVGZmBrsHDdn|49WfpyeRe0WlW)90p2zpqFGjE?|^~=*s4zv0KR!lX!7%zmhXktu5I$O!K(uXTYuFmCr3j@lw)%2Z>HRV?rFk`PHNRI~- z*bxoNq^RoXcys;Y%Gf{N@!Pktt?98{bcBH21<-k}LfS3+gIUnl`_sytsg3F5wcQZtCLr~nb^_(c0`u+VJDh?QV z9q@wI*X`H4Frz3;$nn5S4=4CnGsDxcjpp0j!Neqsi4)${%j{uxjT5+jrE+M_(Y<|N zp-Y#!CcMr3qBZxJl}wEcKgQZyK5ndDUfFDEg6}24zzC|_ z^IU5+Rh4OBuosT`O-!2C zZN0xt)JE9Ddm{9^6;lP>5TX+PR~!^V6=cHcUbn=aPsTl-y;N0Iz2P&TDliVaE1342 zE#Y7l5ra-U?agGk#VLrPV(H<@5)u*~UfWZp5Z;C2FfjNFd#$$Rj~hRy8Pw#a8i7JD z{YCc(71IRHbrC9}J>lsaCuj8@v`0t(jClc6anC@_f6V!@q; zMTm=qk@_9pc$NIEqa}cpPEYbe)GUiH&?GUWVaOnEEkN$9m{D>tW)YH>oPX3{#cdP?bZzZ;I<8eECGprw8h;tH zu5NTybr4-+n-IhuhUS@^#?6hqZ#Zll%&U($P&ae1d?Np|^{va6mZ;Qmst9Eg$8{-+ zVtMs}+^iVdZwmgElpBzpiD;2XcWv zJxR#2CSG*z(LCfPLmCLDe2+{$awwgqs=qp!N}rA!lM2P=yg3r0KdLY-t9G7_fBweN zpzQqY$j$i-kog%duOp$8h5p|MvJGx=L!%DLwDnOMftU32@yR zbnOC9A_CE|l1@f`ilHXPFaO@spZ_2UuC_tgV{A+M`P=GJaF#$kn!K8ue8WSMs>tC5 zIz6}ql)O$;7l5hTXynk%)hs_!%iq+hy7SQCo@%yE^E=-jh!^&86U7sagdGXFcXYhP z)Bw|Nme=Qz*b#dy=~2~>$uS#KJxMqJ~|WWv;-|KE)_R@#l*^bYk1!^ zdroAVcCeIf-~Ez-G?kf!kcZs%@n;-8X0YUs>E--*Wk5H8me#*0n4>dFD0WFuCD&++@Eo zb!i?-IcLA|uFwDYO@^Y*^>K4dL34Ik_mb{>n_d6avdi&eJ+vyd95@`v$_cWs+=4hP z|9EL#Ue{*&4^ax#Z0)ntikfR)vFo^+6Xy>jpjEj;ZP)e+_w`=)bJk8)+G#hp){Smg z>6M}8QwSi!V7IhRq<|1|n)+UMLPW*dY;(5!aJ%e3b(~Ub-*p-@J>e#+nNqvPBOgi@xt*+r*bzAc@rP7T zJ1_<7Re~Qzm$0y(0`I%~2G6J#8&Un^W*7h)vk3;b*$skg++Ofa$SO8Z8g4wOdUcy0 z!|(o}U=R&tra-_q%S6($ORG(;YZLjYi}g&J8b|;VwmTf&uN?*=RY`I#42@^W!I!d^ zH<7MlH9(l+VdlnsU$rs?v-xIA$ja+vG2aac7w82c#6Td0?7Ez;o0y%;>^GK#3uS&2 z)kOICY#vbF!fVgTZEZoPKVgjxiNQ_V#eI8w0LG&CZK!hI%@dM1F{%$i!_=;V^UO_* zHLI7q9o3!Rgpfh$Su=inGvRfab0eIB$q{>G{b)2^_ipqMNV9m5=BtIXTeh1OpWEnz z4m!7>&e@X-Ez zOFoKSKpf7`?TCF$vc#mK@``skRT(mJaeiqz`^Uvm;pHvU>(?tGbLID82KMH+r%CMh zNj&S|sEC+BKpB=eYx{)OBU)NON64>S?|tetpQX0`L_MjC`EH?mEXT~kq8~P#TENHJ zy3n0t`z+=3#OC4awI;L?{^E9bsWPZ6yK?C#)&iNe8G@~ofRONXfB*J!^~k|dL81HV z()H@TDn@r5h`2D=Ce7}$@)YvLs;Id*KkU>8>pD0&5 z5|`PVKk~layXTCRA8gH%kxTGx=3&d z(jn$E?ZSc-)rUuXdrSP8StV`W^>Wuk)A>vMsp~-t6Eif#U*N?{D>iGDgv%#6K$fMx zLXs~+D7Z@=4teioSXo#$Uv9K*;?GK2b<$=>YQEKJl7BI$-T%de1utZEOn?!dpsYh;}Uw`aCY~n+eq$kyx^I2DKMCW0*FEl zs{xs|?HlH(%4r}48RUSCv|nmp8MaS*%k)@sYj4)9g3jD*5^HHP_O#x#oc1^QxH?Jl!^6v@aH$6-xM6VX7zEVNkr zhX6$({3T5r8`1Rt2UGe_Zhfv%)eQF=Q3#zDvb>6BbJHf}3P((zT3 z#}DKuPy+k|5u1|qbes9mIm(gD<0j=TuqLfT5D}XJ>GbXPM7B}=_amus&CN{$U+l`c z{`U4vAZps^dKG^=6C4>y)?By@zbV_i(BypBt0Xj{C1Ht)jdgKxNpSDoZ0pW*J;$E< zthQ`whD$T6r#ENwOaNv*B{zGSG*O1)W#BtdXt9JQbWQ{w*4V`rO;zXjI`j3XP|{$- z!h-Qy{;6GEpER$gB-3rPvp=ulT8@s5)#e`ORC#Ccq45NOd1Qoq9plOgZdM@gU;Xo% z+F!m{+;`~G{ld)7z@;(RJ;Q27tm#Lc6YA8tyKL?q@2uY*QHbXf1{Y$SdFnKqPEgRf zSoaR~3OJtOdyrFhQN2Fh$RBSo{Tvt=Gz%YGO+Fc2T)c0+J-)vynDh;opRXEMrw0~| zb?c)+R9$B#qe2&%{NC+iqQk}e<|UEmG|h;r>ua@0G#Y94=C{`owiXZ)J9r-*Rb z-uK-tsDQyvANm7l4F(agE*DTa`pgk&vWCg8V4mx=>veIORQ5bv;_ z!wLi|hqa9^t08yx8~nHBipP}7lqBr>nt*Z%fQGTBKt^PMTFlgu_W+)B)= z(|{A>PN8-cH%+{Ir*2n!Rr6;G1 zX_$bIPWsk6)Um>F{#da&x<$K5%*}Jz3j~@TuP_}S8&ldB(!~?)3ZnpG5vRJmRQ3nOwrm`78@491l}o z{ci9RayTHSz=??PC=ffmhXt3}LH(o`*9u)QwnY#oX*wbc3yV$%GDgbjB0Sc-6!2`Z z+biz=+u?}J^HkR>AUO*pSyVoM2I7=!ahORjsf6B($?<-4`SQh*{Cc(z>f!FLQDw5! z=t)eiVrrUSyNj*O`pA87KR)DR01NtyL?uMcLl8rGCnZ+e_2dxS$a%tW?6GWpf6B%B z-@0D8p%g%bXbAHipVe#?;FSPb(Mt5^3XAn&)6eyX222~?pKm6>X5_5kQfTTxI;kIW zm!$}$oSm(0h#1RNBwc2v@9@dqJi91#3RO{^+DGTw3tffWyRvk~L&rPA{>CvxZ(pjV zEvJy0J3%*$!M8ndR@&X~f`A&@D$8Y?(O(ITXlE3@ zpg!&$NL~ohtU7(f;Y4YL;d95goyJ5!hL=eW4T$`}w+@AzN59PPE^qU>h?6L@JtV>d`4I#5%9xB?uCF8+5zr4I& z-DlsLMv>OS$;gY`jS_2CMG+|=f*)Z zSP`E|y~;D6)@fWtXe6KLNlW(v6Mq_ON=9+n+0CLimq6U66JK2o`#TIt=5bn8Z~a7Y zOb)&PqM#eR+!bR0gNOj1(Cc*4%*W8x;rQxMEzLHGOz>}oTtT>NyK(H!C6)WlHJ3xk z*R@|SJZ}e|9=({*0gw$L##Qg=qBkrnJ2!23 z;BS8ZbMr;!9PN2k8XDv%9@zf8F_4l0Y_ivb+s3b^H-gL!vfBz>9;FFegVxz^ixTom z+^UO7a$g3iE8P)_{SfoKIV$+Gw&sNpNlr;3BB7ir6?4SCk)CQAaatLua& z7c}ZAv@?l=m%WA)D-3;*y`;KY`7@JMCW+n5Q{(wR&2SqGP#Y37OPBQLD)`MLNChu>r zIEK~}HXy}8Pe;D8kcsiGQy`%zeUa8AUQ zED+~8{?!EVK7qugU`NLnxxYeL6>9_pL}|hc4-m8D)warvnHH)pCVJ>f;0IVS$nW z7!M$-06#(!eZv|U9}6Z^0E@GbpBZ3Cu)e!GT5Or*XgMEmK|$L>lTDzwehe{L0cjQr z(DU=t^E>yf_*8un0KIEpJ3c<%p8kCLH0#_M_A^YA*ZOqZ=O=e083*^!RB7gYwTZHz zwoh7G+Pj0Dn@1J^=*0Kwv)t@7r{0s%uW#LNI@K1830dRyJx@_<#Wm}5>Iuh(+VH=# z&741S&7Q(OXvzFH9&-huGoT=4a67-gz_Ks$v6mnT!zuB9r z#DLoW<@l`g1fUQJrlwMkj(*x6)&(eE4rgdeW?9*%Ftw8N>^05rLoE??IV>jgymNX7 z0e$8Gkwk*|U8X4k?w^U*Ya=6@TbqCdd^r+N!JLfokMBS?S?9oFU0L^@`^VGAaW+gY z6=?>g{KWkCbe#YPM@L2553P)2d>8%iUluyrHh@&~-?Po5BT532-)Lo{K)b(x3jn4Q z3PS?-uM=R3>7ULoE-dgUEZ-8_ou2`T>5{avvayARAk_9j-qBB~si~1mLH{b2+B-Rg zg@ytwf;3rKG14-Q*DNgky^VRNFyL-vv{Tkw8!TYSu;-$>x~CcG=%TRKBJIaO+2aKG z_=HuKWUOUrl^h0C0M#&E)mvh`$b35KSCW)i9eqmiik8NWeET4P4SGT;A|81c-mbzT zB7gusGkxUZ*|D**N)?DRjG^p&N0|m}AY?h-(ellZvdDGEz~qC$*xA^Inq6a1 zBl1SAYyghfjus~n-X;xcruCuodz=GEF7rK*$^MUTcv@S*4e$+tSUx~G4CB-8>fIK$ z5H=~1LIWbiEUYYazJQN%bImh}idtcb2k;_4v|7@*Kk_PR0O6M2K!`O zOw2wy`d{XPzvgC-p{yNbJAvciv8pYgtR5ZBc8vG;vrxAzPj}~_fKFtX0quF<4biEhZ)=E+$Ux^XI%tGtq!*jl<)`;3k>0#{q&wrCeMD zXtD|mlMybLdn%#F(}%$yQcDS$N*`zN}SrO}*PwR1<8@$0hml6Ey+}DY31M z7Lc&IZHML@0L(W97A~Bw>btn8pI+kf@l|iVe~(7~_yT-Ce)rCs$K3u4{L3fxPhURn9IfI|5bWl0 zKGx!DbasdcIH<22si_E8@{4sb>IA46OD;}_sA(;2HHIu!=S$nc{IZ6QH< zYJ$w2*!BZCqJN&w{mq*<7IPI$djIIm+rSdq!cJbld4peGGT7dIc2-8_D)Qem<0)o( z_%9t@9UUuM=_LQK&S_a>?*CZM$=co$%I=GH>=yIC9*0?0hMWIie?&lk_V(p781q%D z`n{O{k)BC|TR`%?A-Di6bCLU;K%?2(Uvv;jJ5tW3%0@!8&Gwv@=DAaK9& zK_YEj!dcaKa8Ln+??0|IW{^e^8#_CY72>V-E^6y8E3^CmFQBc|&{kD7I#NmU3!_EF zeCz_mh)H43nqQ>3&_Cz$B^d!2;{i{w|7I9_c;{{GmAy3#$)A@CzSx5xB$2z z-((hbQu?H z8NU{M&^t;%DMbR6UNJB*(9;9R;fj#xu`ts8kdu~{mXo9R9a&x*6{7%dIRv$>t*znW z;aTFu136$+;8j@}Nb+`eWtkX%K#4fPVPR^MrNj!O>FQ=r6A}|;sHD)T0FuM{+L{G^ z4kJB1Jp%)88$Kt<`x4M?Qt$L7H8AZdc z0s-%!PcO~v|EvkLCw_s-%UlSL=cl3ZA#y_hN&-I3?*^t0Oh+ioc{h~$*>e!}b3nb8 znuM=%meRHVU_4!=vwX_Lvxn=oV-nA1x_LH2Q94`&@HOaTelG)^ca&+$jZ+5<&r2V2 z>u+mOW12;HKLx!V{JO>m^z%uJzaf0|?I-u8P)a^&9)zP6O^f5x#u6mZ2Vfhh(GS_y zU3sRb(j~?C_x_w_!`HXM-%>o60)eD~34W1yf)TfCIru75H>j2;-c5QeG5c3iV0zk{ zGQbcpq#x3G3v-tQgoHSJf1iv|bX7TnqG`4_O7l&S7U*Goj(8u_6r7u8sU7yBAeEz&nTPpuWtEi{5gGgea?M(|0+jBCb$lI)V#c+x6DL{#N z_t%6+m~xJZ0jq-_!Sk1URGjL3&$8A_My7vMD^VsJH=gnrD;<+dmpuH`2+bg=#NPg0 zgd_uyxpuaYy3si*iQrWF4VXQpWn|DwAF#+RQ(uZIdao1JE$H*{_%!3yk_M(E^qH2T z^h$R65@)k_2@gpeey52pVSyzJXWyhu@#W| zf+(0su{yiDa&mI)+&Cw6wG@)MwjS3pcBiZxh4+BU^0eT!WxXs=Tax@gIkzF~xy}gBT z9QUj|0TsjtGKWE#pQD-TZ)UXood8uBm|qnJ93Xrn&RP==Ej-{f$J%DaOkWK9`aZRK z&E&a4xmvf2%IB1JiAj}WZzcl*b#ukT-vh_y!`+M5ZPpwl#nK^TfHnzn!!EB?p(lvP zDVFA=)EtdhT9hyRJ?~2fW_a}~LlKCs%k8*eQval-unQprkHt%DtoU)8ZO9jPv#N-S z{%9zrmye8~jaf{Osz&Wx7Z&Wpa=Ib$c@?wB4f1A5k5eSb#o%RzB7MLuKHPNl@P?w-pvE*j*v8a7vw0LP2vV+)^gC8{gPRrk{B_@JTo397<%6$f-a6@+phXG} zoDA9`MkJ6H_8b_whuZGSfY8D=E~`=Jan3(+&D-z=u|i^YB{aV39K3=)lm+)$MZGx+ z?N#)V@6~U3>mfbx=}&8(67c=dilAJj2R-0<0x?{`^yA;v0%rhZL&J?oA76g{we{KI zdYj+}d&WWi($LPzStK%;Kbg7~u1X7?pv>AKcjZjZgP|VV?<#BnncrpExRGgi+Cv40QD&bT8W;g^EYbN<83lD1bdu6&8XQE+ z8wdJM&~azNg@)KvVc z!a%X3vIK+90(EZ`Bxjdq88i)$y;nDu6 zW?h&FxhZq|QdhHV2|@EWFYX?V$%l-TlnC#QQt=+~f`kLY{BcYgM_-8mw>ix_qOYIm z`Zol6y)Ya3%ORZ~!r^goa-9#4hw}|RH3=_6XvmcHu+(CX5c0~v4E9%K`6sm)^VuKm zPU=Qh8FXC$B=Ch!K!9YLK{d^=e%|TE@T@*J~;;8hZZ zD4RxxQN7rpo}_VcXn>9$lkTlq9wIUR_T*okPJmD=5SQ&|6ijObUr zIm0vFT)q~<>4B}aHAk{PDjN*by+V2xoGQ}oNnBk?juYRYDHS6-&j67~AT?g=GrXEJ zbbR`ba@7lIJwbbo|3K+o0)Bp54iD=>MyL7$Q(b& zdmnht{(&fNg*U`+t3eo@2byf90r|<~P#;X_-&Vb=h!7UGTNNd~oI2ZCUo3ur=Y0^J zVjupm(K``^RGDc1X$(!JuF$KO2IoY?nS(5Yn>_04viA1swp^KA*2bN@*Ah26j3l{) z|NOZcd>56O3S|nM7o#=bl7kgk3qN<2e<%}8oEHpYO36Sc`>z%$Nn^>N{GDZ}4KbsG zjn=8DxbaTV;pz_ZYia=8%%_4{T#t^9fKRr(wHF&)#z)0VSQ)PqiNWsha2hdk?LY}1 z)oMywx3OUm z6R0pL2dFHRvA{DuPQkX&yR*sFsU(b!nyOS*Rbe$WD&xV#%^liDaLOg4pkNf`%M|Io z@yk_4<@NcRM(*ES-d+L#O93UyMAuZ+kF_M;qkr>*W*pK#$G9cN_L=SHw?8awIMROn z^Lf34xcFZ16Jb2_b1N=+IoJ0qY(ZfSIS2rXrFG8F{=>hRF+FVT4f!T=dOt%j3Zohg z?375%17_=fq&O7%K04It5xC2XGbE@%s}X|N=uXU}K8C((LpOu*!4%mqg{`dix6XpT zD*&tRb$GN5P2n}v1HLg`k%8(qQ(~uYpcfGV5d@OQvb*zRMny?U$;|Aph_$kblJ+Ty zz+p4p%79Ix50Ayg`-0ERF*1`Mhti^>qYM9)N#Fw;@3o#46J6= z_Z+Eh+EVQst z>110}BBwQBL`N-@&F{%b4ke)d*h+wJR?zslc993C*j{FQ;U-*08R$ znaI=mt4@$n@a*rzQ=crLhAspQ8t~JMlti+z+tizDZ2{77w6!y}%LM=frI#_tYz79Z zswyN8HHa3Giy>*bB=v2{@~I1sMq8XE_Bzm@&%EGtN@OI!=;NIWUvzv*pMfV((tQzC zwwPioBZJ;}-DPSNnF0w#^=GiQxNvC6=?MbRFhV~yJe=A+Qd6tNr||A69-!a0={MLU zSTbk5qH2#g37bR3t)h!ULb*GtC;?Z6jBH;kBG}xR%F-#*)T?Vdq-S2s6+3IGY(zf5 zD-M3vGgV@BMD~20B|ocrom)Bfpx}d8$Cv=^Fjdl4k&9-jS0Gx8#DF1{wt#!ZaAzB0 zhNudz9i`zhEI${dt8;f_XrFzHq}CRq(a{`~Vzg%MdoYgPiK4*e7-O@_FR>RhVx{{m zq^cIbhTeWPb05~=ICoKRaqx!;jHi$rLbNO`KbEdq$N}w%(fsL|sN^>9vnVBqNzXc< zQP}@F=JN%l;C-4=VNB5Z^q)R4H{OwMJ+`xp@rvPTq{bz|ZxBP!t6H-zv%v^rh(y4ul&^#aQ`knH88=JBL%PvM$MhzWWDk%=7N5L)I3U*nfyiuIPd;5Wv!qC=Wh*f)Wr+aXXbz6i z8;3G>R8q9A?rvE?W7WtHlEXou7ov~(a{~+PdudeTAe0RLfW?=%?MWV}HMKLK)F+YGFx=|pi$3d`{D`O>0NP3n-YYfTZyr; zBJ4)@ZL+w#PoPrTsTALid<@UIOP)`?ISP_@qYU^EWR}Try&(2J?1hlb8pLY#lEu!d z{IbK=2BNpV{&RdF$J}Vz@hIb~WP9KE|C>*8P zjRqb`=ZRG}o{39aWX%VsGbR#v>9ylR7|+&zQ8chS zb9@U4#+oCHzUMWpdFFpB41>QW0Bfj!_MuG({%D(MJ6-7fwKb_CyxM7M`R!}xeuJa7 z{`>E8zrrG`*i7R>a(VQoRgN4x75lP#QYgLkd16l@?)7B>>>5dLP01V8`sb93v$$>H zEWVzpdTT#?$tH+B46gl_&*s zZ2cQfS*Nlgd)(zUMx9SER(rmfaSp&&&QZDaT=?_5C0F*$PDL3_#nvF;C_Y|>2a?VQ zEL!)cL|@t5FT&xhvu^_q)J5k#N4wE^2aJEpd<0ysg(=^%`PA|&35Hwp68Ws0oWR+8 zARw`%rxfN5*G`v*piB+x=(&9>EsBhxi+nwAotP?huwG?nxqvn2%x8KlI?J+MNv6M_ ztBl~-N$!(eu1D|E}_yD42v3QUmmDi1++595Sue06)Z^2$-!_fa*$gdDZ zvLn~v`ERmZexll~?@ERW5cmv7Mz74n*-`C-O zk?UeB#~q6SjOvZ>{c9jT0KnU#IgNyI+ck4_MF@!dqq)gEzKed}*Fuu=XJH2v|!ZP8@%y z$Yr=rc}gO4sxIOpDHdVhmC9H6BlbC()r*1IyN zwcdSYPo?3@eQc#2J6|M$)af;4cr>#j@7xhP?nu)Zpks+;!Ttdj$9V51alaIp`VmUOs30|rziTo{BG>mIAL3PEQT`?r zQ|2n`_Gk{-=J6T9Zm*|^c4D`O!TmcZNiowCxlkwTivepIhEsY8_r@kpXLm$z*@L9A z8wB*Cyc=v0?`a5EQ8HoNB6ldvt+1BebX=kFq@gDT;9TSyl;zo%2w~_85(!glWDHzr zb!yB!9gV@E{cL_o=udiy{g`i2iS9l-k3XqFu3DOYJCUI7HIKP=i;T->KrBuYm5b+E?hqy?=g z(-q8b@b|ARXLM_i{7SAudyDWRM8jBMe$p8O{rfYa$j?7JCN>Z~u_~(px~5{jSzA24 zTqt5W!Qisn~QG#2ifJ+I%(B!=px(lY0-k<50H= z{nGUnIXh>bNB5}BYyYaeq@?O|Pr{4Z`beutyqas1u{#n>7qx9)al(^H&}dqks#(h@ z5S44QisD9M*3fR0SWQWyXL_-n@2X;t2YK-yXR1x4-(D9v``d+NO5cX?lSbaFqJ_J* z(JNn;VNGB`&z3!WJc-iGe|kmNlq@pSqvX1sYR5*^ZJ&>@Wn{@)XJ!J~t-s346{=rK znVu6pTT!$5=JA+G$l`W~8=Oc3?dS&5^NXxFBR7m&Nsz#4cUR-y`pNRIh>Q5P@xi_bcEOzPsISrZKp0~lpQD|p3xmO+P{1;3Fn{st&=ZHUi=i}hSdzNB zy7Re_&7~orIYHFbLu>Q50pDj=7jUYE7bu+hcnAvtnZ%{qvoU7t6Ceun0%ZYScx`Ph zXC8DU{4Q|xVSm3jqwHI_m5(4LYuI{0aJ%@RA9#l>1hB!ARz#vn6v;zuaObpGzz>PZ zsapxGK`AwR_=l@+r2!2mbo01+WMW5a{PgcD{IE7h5)S+!0G6|zK}D< zP~E2C1OrlAkofu-f%QXM*1*&H=>HhVDJt>;JG)pO2AQZ@mqB?svO=YVLNVT3D#rQd z-d", + "label": "v: ", + "range": { + "start": 1096, + "end": 1151 + }, + "inputs": [] + } + ], + "edges": [], + "roots": [ + "v", + "v" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "vh.eq(&e1)", + "resolved_text": "vh.eq(&e1)", + "semantic_text": "vh == e1", + "referenced_vars": [], + "range": { + "start": 1460, + "end": 1470 + } + }, + { + "id": "constraint_1", + "source_text": "vh.eq(&e2)", + "resolved_text": "vh.eq(&e2)", + "semantic_text": "vh == e2", + "referenced_vars": [], + "range": { + "start": 1479, + "end": 1489 + } + } + ], + "action_effects": [], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "a", + "template": "a", + "fields": [] + }, + { + "variant_name": "b", + "template": "b", + "fields": [] + } + ], + "precedence_templates": [ + { + "variant_name": "a", + "precedence": 100 + }, + { + "variant_name": "b", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "vec_check_vec_of", + "premises": [ + { + "target_id": "v", + "label": "v: ", + "plain_source": "v", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ v $]" + }, + { + "target_id": "v", + "label": "v: ", + "plain_source": "v", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ v $]" + } + ], + "side_conditions": [ + "upright(\"vh\") == e_1", + "upright(\"vh\") == e_2" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(v \\ v, upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"vh\") == e_1 \\ upright(\"vh\") == e_2", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ v $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ v $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"vh\") == e_1 \\ upright(\"vh\") == e_2" + } + } + } + }, + { + "id": "benches_runners_eggplant_rewrite_vec_builtins_rs__70_5_MyTxVec_add_rule__vec_check_vec_append__75215e25e1174623", + "display_name": "vec_check_vec_append", + "rule_name": "vec_check_vec_append", + "callee": "MyTxVec::add_rule", + "file": "benches/runners/eggplant_rewrite/vec_builtins.rs", + "offset": 1614, + "line": 70, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 1614, + "end": 2211 + }, + "pattern_range": { + "start": 1685, + "end": 2179 + }, + "action_range": { + "start": 2189, + "end": 2204 + } + }, + "nodes": [ + { + "id": "v", + "kind": "query", + "dsl_type": "", + "label": "v: ", + "range": { + "start": 1702, + "end": 1757 + }, + "inputs": [] + } + ], + "edges": [], + "roots": [ + "v", + "v" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "vh.eq(&lhs)", + "resolved_text": "vh.eq(&lhs)", + "semantic_text": "vh == lhs", + "referenced_vars": [], + "range": { + "start": 2137, + "end": 2148 + } + }, + { + "id": "constraint_1", + "source_text": "vh.eq(&rhs)", + "resolved_text": "vh.eq(&rhs)", + "semantic_text": "vh == rhs", + "referenced_vars": [], + "range": { + "start": 2157, + "end": 2168 + } + } + ], + "action_effects": [], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "a", + "template": "a", + "fields": [] + }, + { + "variant_name": "b", + "template": "b", + "fields": [] + } + ], + "precedence_templates": [ + { + "variant_name": "a", + "precedence": 100 + }, + { + "variant_name": "b", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "vec_check_vec_append", + "premises": [ + { + "target_id": "v", + "label": "v: ", + "plain_source": "v", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ v $]" + }, + { + "target_id": "v", + "label": "v: ", + "plain_source": "v", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ v $]" + } + ], + "side_conditions": [ + "upright(\"vh\") == upright(\"lhs\")", + "upright(\"vh\") == upright(\"rhs\")" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(v \\ v, upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"vh\") == upright(\"lhs\") \\ upright(\"vh\") == upright(\"rhs\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ v $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ v $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"vh\") == upright(\"lhs\") \\ upright(\"vh\") == upright(\"rhs\")" + } + } + } + }, + { + "id": "benches_runners_eggplant_rewrite_vec_builtins_rs__89_5_MyTxVec_add_rule__vec_check_vec_pop__ccf6b2f2fdac815a", + "display_name": "vec_check_vec_pop", + "rule_name": "vec_check_vec_pop", + "callee": "MyTxVec::add_rule", + "file": "benches/runners/eggplant_rewrite/vec_builtins.rs", + "offset": 2275, + "line": 89, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 2275, + "end": 2803 + }, + "pattern_range": { + "start": 2343, + "end": 2771 + }, + "action_range": { + "start": 2781, + "end": 2796 + } + }, + "nodes": [ + { + "id": "v", + "kind": "query", + "dsl_type": "", + "label": "v: ", + "range": { + "start": 2360, + "end": 2415 + }, + "inputs": [] + } + ], + "edges": [], + "roots": [ + "v", + "v" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "vh.eq(&lhs)", + "resolved_text": "vh.eq(&lhs)", + "semantic_text": "vh == lhs", + "referenced_vars": [], + "range": { + "start": 2729, + "end": 2740 + } + }, + { + "id": "constraint_1", + "source_text": "vh.eq(&rhs)", + "resolved_text": "vh.eq(&rhs)", + "semantic_text": "vh == rhs", + "referenced_vars": [], + "range": { + "start": 2749, + "end": 2760 + } + } + ], + "action_effects": [], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "a", + "template": "a", + "fields": [] + }, + { + "variant_name": "b", + "template": "b", + "fields": [] + } + ], + "precedence_templates": [ + { + "variant_name": "a", + "precedence": 100 + }, + { + "variant_name": "b", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "vec_check_vec_pop", + "premises": [ + { + "target_id": "v", + "label": "v: ", + "plain_source": "v", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ v $]" + }, + { + "target_id": "v", + "label": "v: ", + "plain_source": "v", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ v $]" + } + ], + "side_conditions": [ + "upright(\"vh\") == upright(\"lhs\")", + "upright(\"vh\") == upright(\"rhs\")" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(v \\ v, upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"vh\") == upright(\"lhs\") \\ upright(\"vh\") == upright(\"rhs\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ v $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ v $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"vh\") == upright(\"lhs\") \\ upright(\"vh\") == upright(\"rhs\")" + } + } + } + }, + { + "id": "benches_runners_eggplant_rewrite_vec_builtins_rs__107_5_MyTxVec_add_rule__vec_check_vec_not_contains__70d6ccc269dabc5f", + "display_name": "vec_check_vec_not_contains", + "rule_name": "vec_check_vec_not_contains", + "callee": "MyTxVec::add_rule", + "file": "benches/runners/eggplant_rewrite/vec_builtins.rs", + "offset": 2861, + "line": 107, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 2861, + "end": 3170 + }, + "pattern_range": { + "start": 2938, + "end": 3138 + }, + "action_range": { + "start": 3148, + "end": 3163 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Pat" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "e", + "resolved_text": "vec_of::([&1_i64, &2_i64, &3_i64]).vec_not_contains(&4_i64)", + "semantic_text": null, + "referenced_vars": [], + "range": { + "start": 3126, + "end": 3127 + } + } + ], + "action_effects": [], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "a", + "template": "a", + "fields": [] + }, + { + "variant_name": "b", + "template": "b", + "fields": [] + } + ], + "precedence_templates": [ + { + "variant_name": "a", + "precedence": 100 + }, + { + "variant_name": "b", + "precedence": 100 + } + ], + "diagnostics": [ + { + "severity": "warning", + "message": "Pat::new(...) found, but no root variables could be extracted", + "range": { + "start": 3108, + "end": 3118 + } + } + ], + "math_view": { + "rule_name": "vec_check_vec_not_contains", + "premises": [ + { + "target_id": "Pat", + "label": "Pat", + "plain_source": "upright(\"Pat\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Pat\") $]" + } + ], + "side_conditions": [ + "e [raw]" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"Pat\"), upright(\"no conclusion\")) quad upright(\"if\") quad e [raw]", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Pat\") $], upright(\"no conclusion\")) quad upright(\"if\") quad e [raw]" + } + } + } + }, + { + "id": "benches_runners_eggplant_rewrite_vec_builtins_rs__120_5_MyTxVec_add_rule__vec_check_vec_contains__784a2dc038ccd3ac", + "display_name": "vec_check_vec_contains", + "rule_name": "vec_check_vec_contains", + "callee": "MyTxVec::add_rule", + "file": "benches/runners/eggplant_rewrite/vec_builtins.rs", + "offset": 3224, + "line": 120, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 3224, + "end": 3525 + }, + "pattern_range": { + "start": 3297, + "end": 3493 + }, + "action_range": { + "start": 3503, + "end": 3518 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Pat" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "e", + "resolved_text": "vec_of::([&1_i64, &2_i64, &3_i64]).vec_contains(&2_i64)", + "semantic_text": null, + "referenced_vars": [], + "range": { + "start": 3481, + "end": 3482 + } + } + ], + "action_effects": [], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "a", + "template": "a", + "fields": [] + }, + { + "variant_name": "b", + "template": "b", + "fields": [] + } + ], + "precedence_templates": [ + { + "variant_name": "a", + "precedence": 100 + }, + { + "variant_name": "b", + "precedence": 100 + } + ], + "diagnostics": [ + { + "severity": "warning", + "message": "Pat::new(...) found, but no root variables could be extracted", + "range": { + "start": 3463, + "end": 3473 + } + } + ], + "math_view": { + "rule_name": "vec_check_vec_contains", + "premises": [ + { + "target_id": "Pat", + "label": "Pat", + "plain_source": "upright(\"Pat\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Pat\") $]" + } + ], + "side_conditions": [ + "e [raw]" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"Pat\"), upright(\"no conclusion\")) quad upright(\"if\") quad e [raw]", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Pat\") $], upright(\"no conclusion\")) quad upright(\"if\") quad e [raw]" + } + } + } + }, + { + "id": "benches_runners_eggplant_rewrite_vec_builtins_rs__133_5_MyTxVec_add_rule__vec_check_vec_length__8df151de922b53b1", + "display_name": "vec_check_vec_length", + "rule_name": "vec_check_vec_length", + "callee": "MyTxVec::add_rule", + "file": "benches/runners/eggplant_rewrite/vec_builtins.rs", + "offset": 3581, + "line": 133, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 3581, + "end": 4046 + }, + "pattern_range": { + "start": 3652, + "end": 4014 + }, + "action_range": { + "start": 4024, + "end": 4039 + } + }, + "nodes": [ + { + "id": "v", + "kind": "query", + "dsl_type": "", + "label": "v: ", + "range": { + "start": 3669, + "end": 3723 + }, + "inputs": [] + } + ], + "edges": [], + "roots": [ + "v", + "v" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "vh.eq(&e)", + "resolved_text": "vh.eq(&e)", + "semantic_text": "vh == e", + "referenced_vars": [], + "range": { + "start": 3972, + "end": 3981 + } + }, + { + "id": "constraint_1", + "source_text": "vh.eq(&3_i64)", + "resolved_text": "vh.eq(&3_i64)", + "semantic_text": "vh == 3", + "referenced_vars": [], + "range": { + "start": 3990, + "end": 4003 + } + } + ], + "action_effects": [], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "a", + "template": "a", + "fields": [] + }, + { + "variant_name": "b", + "template": "b", + "fields": [] + } + ], + "precedence_templates": [ + { + "variant_name": "a", + "precedence": 100 + }, + { + "variant_name": "b", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "vec_check_vec_length", + "premises": [ + { + "target_id": "v", + "label": "v: ", + "plain_source": "v", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ v $]" + }, + { + "target_id": "v", + "label": "v: ", + "plain_source": "v", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ v $]" + } + ], + "side_conditions": [ + "upright(\"vh\") == e", + "upright(\"vh\") == 3" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(v \\ v, upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"vh\") == e \\ upright(\"vh\") == 3", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ v $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ v $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"vh\") == e \\ upright(\"vh\") == 3" + } + } + } + }, + { + "id": "benches_runners_eggplant_rewrite_vec_builtins_rs__150_5_MyTxVec_add_rule__vec_check_vec_get__479c4f8556bc6608", + "display_name": "vec_check_vec_get", + "rule_name": "vec_check_vec_get", + "callee": "MyTxVec::add_rule", + "file": "benches/runners/eggplant_rewrite/vec_builtins.rs", + "offset": 4101, + "line": 150, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 4101, + "end": 4569 + }, + "pattern_range": { + "start": 4169, + "end": 4537 + }, + "action_range": { + "start": 4547, + "end": 4562 + } + }, + "nodes": [ + { + "id": "v", + "kind": "query", + "dsl_type": "", + "label": "v: ", + "range": { + "start": 4186, + "end": 4240 + }, + "inputs": [] + } + ], + "edges": [], + "roots": [ + "v", + "v" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "vh.eq(&e)", + "resolved_text": "vh.eq(&e)", + "semantic_text": "vh == e", + "referenced_vars": [], + "range": { + "start": 4495, + "end": 4504 + } + }, + { + "id": "constraint_1", + "source_text": "vh.eq(&2_i64)", + "resolved_text": "vh.eq(&2_i64)", + "semantic_text": "vh == 2", + "referenced_vars": [], + "range": { + "start": 4513, + "end": 4526 + } + } + ], + "action_effects": [], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "a", + "template": "a", + "fields": [] + }, + { + "variant_name": "b", + "template": "b", + "fields": [] + } + ], + "precedence_templates": [ + { + "variant_name": "a", + "precedence": 100 + }, + { + "variant_name": "b", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "vec_check_vec_get", + "premises": [ + { + "target_id": "v", + "label": "v: ", + "plain_source": "v", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ v $]" + }, + { + "target_id": "v", + "label": "v: ", + "plain_source": "v", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ v $]" + } + ], + "side_conditions": [ + "upright(\"vh\") == e", + "upright(\"vh\") == 2" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(v \\ v, upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"vh\") == e \\ upright(\"vh\") == 2", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ v $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ v $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"vh\") == e \\ upright(\"vh\") == 2" + } + } + } + }, + { + "id": "benches_runners_eggplant_rewrite_vec_builtins_rs__167_5_MyTxVec_add_rule__vec_check_vec_set__2b0b04d317673fca", + "display_name": "vec_check_vec_set", + "rule_name": "vec_check_vec_set", + "callee": "MyTxVec::add_rule", + "file": "benches/runners/eggplant_rewrite/vec_builtins.rs", + "offset": 4639, + "line": 167, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 4639, + "end": 5189 + }, + "pattern_range": { + "start": 4707, + "end": 5157 + }, + "action_range": { + "start": 5167, + "end": 5182 + } + }, + "nodes": [ + { + "id": "v", + "kind": "query", + "dsl_type": "", + "label": "v: ", + "range": { + "start": 4724, + "end": 4779 + }, + "inputs": [] + } + ], + "edges": [], + "roots": [ + "v", + "v" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "vh.eq(&lhs)", + "resolved_text": "vh.eq(&lhs)", + "semantic_text": "vh == lhs", + "referenced_vars": [], + "range": { + "start": 5115, + "end": 5126 + } + }, + { + "id": "constraint_1", + "source_text": "vh.eq(&rhs)", + "resolved_text": "vh.eq(&rhs)", + "semantic_text": "vh == rhs", + "referenced_vars": [], + "range": { + "start": 5135, + "end": 5146 + } + } + ], + "action_effects": [], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "a", + "template": "a", + "fields": [] + }, + { + "variant_name": "b", + "template": "b", + "fields": [] + } + ], + "precedence_templates": [ + { + "variant_name": "a", + "precedence": 100 + }, + { + "variant_name": "b", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "vec_check_vec_set", + "premises": [ + { + "target_id": "v", + "label": "v: ", + "plain_source": "v", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ v $]" + }, + { + "target_id": "v", + "label": "v: ", + "plain_source": "v", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ v $]" + } + ], + "side_conditions": [ + "upright(\"vh\") == upright(\"lhs\")", + "upright(\"vh\") == upright(\"rhs\")" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(v \\ v, upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"vh\") == upright(\"lhs\") \\ upright(\"vh\") == upright(\"rhs\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ v $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ v $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"vh\") == upright(\"lhs\") \\ upright(\"vh\") == upright(\"rhs\")" + } + } + } + }, + { + "id": "benches_runners_eggplant_rewrite_vec_builtins_rs__196_5_MyTxVec_add_rule__vec_rebuild_seed__72dac973d74ec269", + "display_name": "vec_rebuild_seed", + "rule_name": "vec_rebuild_seed", + "callee": "MyTxVec::add_rule", + "file": "benches/runners/eggplant_rewrite/vec_builtins.rs", + "offset": 5841, + "line": 196, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 5841, + "end": 6303 + }, + "pattern_range": { + "start": 5910, + "end": 5991 + }, + "action_range": { + "start": 6001, + "end": 6296 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Unit" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@6035:6049", + "bound_var": "a", + "source_text": "ctx.insert_a()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 6035, + "end": 6049 + } + }, + { + "id": "effect_1", + "effect_id": "effect@6071:6085", + "bound_var": "b", + "source_text": "ctx.insert_b()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 6071, + "end": 6085 + } + }, + { + "id": "effect_2", + "effect_id": "effect@6173:6185", + "bound_var": null, + "source_text": "ctx.set_p(p)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 6173, + "end": 6185 + } + }, + { + "id": "effect_3", + "effect_id": "effect@6273:6285", + "bound_var": null, + "source_text": "ctx.set_q(q)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 6273, + "end": 6285 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "a", + "template": "a", + "fields": [] + }, + { + "variant_name": "b", + "template": "b", + "fields": [] + } + ], + "precedence_templates": [ + { + "variant_name": "a", + "precedence": 100 + }, + { + "variant_name": "b", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "vec_rebuild_seed", + "premises": [ + { + "target_id": "Unit", + "label": "Unit", + "plain_source": "upright(\"Unit\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "a", + "plain_source": "A()", + "colored_source": "A()" + }, + { + "target_id": "effect:effect_1", + "label": "b", + "plain_source": "B()", + "colored_source": "B()" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "a", + "plain_source": "A()", + "colored_source": "A()" + } + }, + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "b", + "plain_source": "B()", + "colored_source": "B()" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"Unit\"), A() \\ B()) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $], A() \\ B()) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_eggplant_rewrite_vec_builtins_rs__231_5_MyTxVec_add_rule__vec_rebuild_union__79d0540b12b44519", + "display_name": "vec_rebuild_union", + "rule_name": "vec_rebuild_union", + "callee": "MyTxVec::add_rule", + "file": "benches/runners/eggplant_rewrite/vec_builtins.rs", + "offset": 6859, + "line": 231, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 6859, + "end": 7148 + }, + "pattern_range": { + "start": 6926, + "end": 7007 + }, + "action_range": { + "start": 7017, + "end": 7141 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Unit" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@7051:7065", + "bound_var": "a", + "source_text": "ctx.insert_a()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 7051, + "end": 7065 + } + }, + { + "id": "effect_1", + "effect_id": "effect@7087:7101", + "bound_var": "b", + "source_text": "ctx.insert_b()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 7087, + "end": 7101 + } + }, + { + "id": "effect_2", + "effect_id": "effect@7115:7130", + "bound_var": null, + "source_text": "ctx.union(a, b)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "a", + "b" + ], + "range": { + "start": 7115, + "end": 7130 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "a", + "template": "a", + "fields": [] + }, + { + "variant_name": "b", + "template": "b", + "fields": [] + } + ], + "precedence_templates": [ + { + "variant_name": "a", + "precedence": 100 + }, + { + "variant_name": "b", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "vec_rebuild_union", + "premises": [ + { + "target_id": "Unit", + "label": "Unit", + "plain_source": "upright(\"Unit\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"Unit\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_eggplant_rewrite_web_demo_set_rs__101_5_MyTxSet_add_rule__web_demo_set_checks_seed_consts__ed77d5f1e1c43a0f", + "display_name": "web_demo_set_checks_seed_consts", + "rule_name": "web_demo_set_checks_seed_consts", + "callee": "MyTxSet::add_rule", + "file": "benches/runners/eggplant_rewrite/web_demo_set.rs", + "offset": 2889, + "line": 101, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 2889, + "end": 3726 + }, + "pattern_range": { + "start": 2980, + "end": 3061 + }, + "action_range": { + "start": 3071, + "end": 3719 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Unit" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@3346:3374", + "bound_var": null, + "source_text": "ctx.set_s_empty(mk_set(&[]))", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 3346, + "end": 3374 + } + }, + { + "id": "effect_1", + "effect_id": "effect@3388:3416", + "bound_var": null, + "source_text": "ctx.set_s12(mk_set(&[1, 2]))", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 3388, + "end": 3416 + } + }, + { + "id": "effect_2", + "effect_id": "effect@3430:3458", + "bound_var": null, + "source_text": "ctx.set_s34(mk_set(&[3, 4]))", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 3430, + "end": 3458 + } + }, + { + "id": "effect_3", + "effect_id": "effect@3472:3508", + "bound_var": null, + "source_text": "ctx.set_s1234(mk_set(&[1, 2, 3, 4]))", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 3472, + "end": 3508 + } + }, + { + "id": "effect_4", + "effect_id": "effect@3522:3554", + "bound_var": null, + "source_text": "ctx.set_s111(mk_set(&[1, 1, 1]))", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 3522, + "end": 3554 + } + }, + { + "id": "effect_5", + "effect_id": "effect@3568:3606", + "bound_var": null, + "source_text": "ctx.set_s1m111(mk_set(&[1, -1, 1, 1]))", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 3568, + "end": 3606 + } + }, + { + "id": "effect_6", + "effect_id": "effect@3620:3662", + "bound_var": null, + "source_text": "ctx.set_s1m1241(mk_set(&[1, -1, 2, 4, 1]))", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 3620, + "end": 3662 + } + }, + { + "id": "effect_7", + "effect_id": "effect@3676:3708", + "bound_var": null, + "source_text": "ctx.set_s123(mk_set(&[1, 2, 3]))", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 3676, + "end": 3708 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "Seen", + "template": "Seen({j})", + "fields": [ + "j" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Seen", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "web_demo_set_checks_seed_consts", + "premises": [ + { + "target_id": "Unit", + "label": "Unit", + "plain_source": "upright(\"Unit\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"Unit\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_eggplant_rewrite_web_demo_set_rs__182_5_MyTxSet_add_rule__set_check_set_of_12_push_12__36471966bdbda495", + "display_name": "set_check_set_of_12_push_12", + "rule_name": "set_check_set_of_12_push_12", + "callee": "MyTxSet::add_rule", + "file": "benches/runners/eggplant_rewrite/web_demo_set.rs", + "offset": 5622, + "line": 182, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 5622, + "end": 6434 + }, + "pattern_range": { + "start": 5704, + "end": 6402 + }, + "action_range": { + "start": 6412, + "end": 6427 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "expected", + "empty", + "expected", + "empty" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "expected_h.eq(&rhs)", + "resolved_text": "expected_h.eq(&rhs)", + "semantic_text": "expected_h == rhs", + "referenced_vars": [], + "range": { + "start": 6372, + "end": 6391 + } + } + ], + "action_effects": [], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "Seen", + "template": "Seen({j})", + "fields": [ + "j" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Seen", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "set_check_set_of_12_push_12", + "premises": [ + { + "target_id": "expected", + "label": "expected", + "plain_source": "upright(\"expected\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expected\") $]" + }, + { + "target_id": "empty", + "label": "empty", + "plain_source": "upright(\"empty\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"empty\") $]" + }, + { + "target_id": "expected", + "label": "expected", + "plain_source": "upright(\"expected\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expected\") $]" + }, + { + "target_id": "empty", + "label": "empty", + "plain_source": "upright(\"empty\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"empty\") $]" + } + ], + "side_conditions": [ + "upright(\"expected_h\") == upright(\"rhs\")" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"expected\") \\ upright(\"empty\") \\ upright(\"expected\") \\ upright(\"empty\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"expected_h\") == upright(\"rhs\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expected\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"empty\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expected\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"empty\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"expected_h\") == upright(\"rhs\")" + } + } + } + }, + { + "id": "benches_runners_eggplant_rewrite_web_demo_set_rs__205_5_MyTxSet_add_rule__set_check_set_of_12_push_21__2b17673010bd1ad3", + "display_name": "set_check_set_of_12_push_21", + "rule_name": "set_check_set_of_12_push_21", + "callee": "MyTxSet::add_rule", + "file": "benches/runners/eggplant_rewrite/web_demo_set.rs", + "offset": 6440, + "line": 205, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 6440, + "end": 7252 + }, + "pattern_range": { + "start": 6522, + "end": 7220 + }, + "action_range": { + "start": 7230, + "end": 7245 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "expected", + "empty", + "expected", + "empty" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "expected_h.eq(&rhs)", + "resolved_text": "expected_h.eq(&rhs)", + "semantic_text": "expected_h == rhs", + "referenced_vars": [], + "range": { + "start": 7190, + "end": 7209 + } + } + ], + "action_effects": [], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "Seen", + "template": "Seen({j})", + "fields": [ + "j" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Seen", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "set_check_set_of_12_push_21", + "premises": [ + { + "target_id": "expected", + "label": "expected", + "plain_source": "upright(\"expected\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expected\") $]" + }, + { + "target_id": "empty", + "label": "empty", + "plain_source": "upright(\"empty\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"empty\") $]" + }, + { + "target_id": "expected", + "label": "expected", + "plain_source": "upright(\"expected\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expected\") $]" + }, + { + "target_id": "empty", + "label": "empty", + "plain_source": "upright(\"empty\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"empty\") $]" + } + ], + "side_conditions": [ + "upright(\"expected_h\") == upright(\"rhs\")" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"expected\") \\ upright(\"empty\") \\ upright(\"expected\") \\ upright(\"empty\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"expected_h\") == upright(\"rhs\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expected\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"empty\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expected\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"empty\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"expected_h\") == upright(\"rhs\")" + } + } + } + }, + { + "id": "benches_runners_eggplant_rewrite_web_demo_set_rs__228_5_MyTxSet_add_rule__set_check_set_union_1234__6aa6bcaf3a60d15c", + "display_name": "set_check_set_union_1234", + "rule_name": "set_check_set_union_1234", + "callee": "MyTxSet::add_rule", + "file": "benches/runners/eggplant_rewrite/web_demo_set.rs", + "offset": 7258, + "line": 228, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 7258, + "end": 8209 + }, + "pattern_range": { + "start": 7337, + "end": 8177 + }, + "action_range": { + "start": 8187, + "end": 8202 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "s12", + "s34", + "expected", + "s12", + "s34", + "expected" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "expected.handle().eq(&lhs)", + "resolved_text": "expected.handle().eq(&lhs)", + "semantic_text": "expected == lhs", + "referenced_vars": [ + "expected" + ], + "range": { + "start": 8140, + "end": 8166 + } + } + ], + "action_effects": [], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "Seen", + "template": "Seen({j})", + "fields": [ + "j" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Seen", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "set_check_set_union_1234", + "premises": [ + { + "target_id": "s12", + "label": "s12", + "plain_source": "s_12", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ s_12 $]" + }, + { + "target_id": "s34", + "label": "s34", + "plain_source": "s_34", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ s_34 $]" + }, + { + "target_id": "expected", + "label": "expected", + "plain_source": "upright(\"expected\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expected\") $]" + }, + { + "target_id": "s12", + "label": "s12", + "plain_source": "s_12", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ s_12 $]" + }, + { + "target_id": "s34", + "label": "s34", + "plain_source": "s_34", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ s_34 $]" + }, + { + "target_id": "expected", + "label": "expected", + "plain_source": "upright(\"expected\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expected\") $]" + } + ], + "side_conditions": [ + "upright(\"expected\") == upright(\"lhs\")" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(s_12 \\ s_34 \\ upright(\"expected\") \\ s_12 \\ s_34 \\ upright(\"expected\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"expected\") == upright(\"lhs\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ s_12 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ s_34 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expected\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ s_12 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ s_34 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expected\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"expected\") == upright(\"lhs\")" + } + } + } + }, + { + "id": "benches_runners_eggplant_rewrite_web_demo_set_rs__255_5_MyTxSet_add_rule__set_check_set_length_empty_0__391b9eb621b9af55", + "display_name": "set_check_set_length_empty_0", + "rule_name": "set_check_set_length_empty_0", + "callee": "MyTxSet::add_rule", + "file": "benches/runners/eggplant_rewrite/web_demo_set.rs", + "offset": 8215, + "line": 255, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 8215, + "end": 8714 + }, + "pattern_range": { + "start": 8298, + "end": 8682 + }, + "action_range": { + "start": 8692, + "end": 8707 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "set", + "set" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "len.eq(&0_i64)", + "resolved_text": "len.eq(&0_i64)", + "semantic_text": "len == 0", + "referenced_vars": [], + "range": { + "start": 8657, + "end": 8671 + } + } + ], + "action_effects": [], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "Seen", + "template": "Seen({j})", + "fields": [ + "j" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Seen", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "set_check_set_length_empty_0", + "premises": [ + { + "target_id": "set", + "label": "set", + "plain_source": "upright(\"set\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $]" + }, + { + "target_id": "set", + "label": "set", + "plain_source": "upright(\"set\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $]" + } + ], + "side_conditions": [ + "upright(\"len\") == 0" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"set\") \\ upright(\"set\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"len\") == 0", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"len\") == 0" + } + } + } + }, + { + "id": "benches_runners_eggplant_rewrite_web_demo_set_rs__272_5_MyTxSet_add_rule__set_check_set_length_of_111_1__4ccee9de694854f1", + "display_name": "set_check_set_length_of_111_1", + "rule_name": "set_check_set_length_of_111_1", + "callee": "MyTxSet::add_rule", + "file": "benches/runners/eggplant_rewrite/web_demo_set.rs", + "offset": 8720, + "line": 272, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 8720, + "end": 9218 + }, + "pattern_range": { + "start": 8804, + "end": 9186 + }, + "action_range": { + "start": 9196, + "end": 9211 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "set", + "set" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "len.eq(&1_i64)", + "resolved_text": "len.eq(&1_i64)", + "semantic_text": "len == 1", + "referenced_vars": [], + "range": { + "start": 9161, + "end": 9175 + } + } + ], + "action_effects": [], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "Seen", + "template": "Seen({j})", + "fields": [ + "j" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Seen", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "set_check_set_length_of_111_1", + "premises": [ + { + "target_id": "set", + "label": "set", + "plain_source": "upright(\"set\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $]" + }, + { + "target_id": "set", + "label": "set", + "plain_source": "upright(\"set\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $]" + } + ], + "side_conditions": [ + "upright(\"len\") == 1" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"set\") \\ upright(\"set\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"len\") == 1", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"len\") == 1" + } + } + } + }, + { + "id": "benches_runners_eggplant_rewrite_web_demo_set_rs__289_5_MyTxSet_add_rule__set_check_set_length_of_1m111_2__18480e5122d77a90", + "display_name": "set_check_set_length_of_1m111_2", + "rule_name": "set_check_set_length_of_1m111_2", + "callee": "MyTxSet::add_rule", + "file": "benches/runners/eggplant_rewrite/web_demo_set.rs", + "offset": 9224, + "line": 289, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 9224, + "end": 9726 + }, + "pattern_range": { + "start": 9310, + "end": 9694 + }, + "action_range": { + "start": 9704, + "end": 9719 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "set", + "set" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "len.eq(&2_i64)", + "resolved_text": "len.eq(&2_i64)", + "semantic_text": "len == 2", + "referenced_vars": [], + "range": { + "start": 9669, + "end": 9683 + } + } + ], + "action_effects": [], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "Seen", + "template": "Seen({j})", + "fields": [ + "j" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Seen", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "set_check_set_length_of_1m111_2", + "premises": [ + { + "target_id": "set", + "label": "set", + "plain_source": "upright(\"set\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $]" + }, + { + "target_id": "set", + "label": "set", + "plain_source": "upright(\"set\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $]" + } + ], + "side_conditions": [ + "upright(\"len\") == 2" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"set\") \\ upright(\"set\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"len\") == 2", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"len\") == 2" + } + } + } + }, + { + "id": "benches_runners_eggplant_rewrite_web_demo_set_rs__306_5_MyTxSet_add_rule__set_check_set_get_1m1241_0_is_1__24163546be65c752", + "display_name": "set_check_set_get_1m1241_0_is_1", + "rule_name": "set_check_set_get_1m1241_0_is_1", + "callee": "MyTxSet::add_rule", + "file": "benches/runners/eggplant_rewrite/web_demo_set.rs", + "offset": 9732, + "line": 306, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 9732, + "end": 10241 + }, + "pattern_range": { + "start": 9818, + "end": 10209 + }, + "action_range": { + "start": 10219, + "end": 10234 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "set", + "set" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "got.eq(&1_i64)", + "resolved_text": "got.eq(&1_i64)", + "semantic_text": "got == 1", + "referenced_vars": [], + "range": { + "start": 10184, + "end": 10198 + } + } + ], + "action_effects": [], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "Seen", + "template": "Seen({j})", + "fields": [ + "j" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Seen", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "set_check_set_get_1m1241_0_is_1", + "premises": [ + { + "target_id": "set", + "label": "set", + "plain_source": "upright(\"set\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $]" + }, + { + "target_id": "set", + "label": "set", + "plain_source": "upright(\"set\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $]" + } + ], + "side_conditions": [ + "upright(\"got\") == 1" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"set\") \\ upright(\"set\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"got\") == 1", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"got\") == 1" + } + } + } + }, + { + "id": "benches_runners_eggplant_rewrite_web_demo_set_rs__323_5_MyTxSet_add_rule__set_check_set_get_1m1241_1_is_2__6f22a421173d0617", + "display_name": "set_check_set_get_1m1241_1_is_2", + "rule_name": "set_check_set_get_1m1241_1_is_2", + "callee": "MyTxSet::add_rule", + "file": "benches/runners/eggplant_rewrite/web_demo_set.rs", + "offset": 10247, + "line": 323, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 10247, + "end": 10756 + }, + "pattern_range": { + "start": 10333, + "end": 10724 + }, + "action_range": { + "start": 10734, + "end": 10749 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "set", + "set" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "got.eq(&2_i64)", + "resolved_text": "got.eq(&2_i64)", + "semantic_text": "got == 2", + "referenced_vars": [], + "range": { + "start": 10699, + "end": 10713 + } + } + ], + "action_effects": [], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "Seen", + "template": "Seen({j})", + "fields": [ + "j" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Seen", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "set_check_set_get_1m1241_1_is_2", + "premises": [ + { + "target_id": "set", + "label": "set", + "plain_source": "upright(\"set\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $]" + }, + { + "target_id": "set", + "label": "set", + "plain_source": "upright(\"set\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $]" + } + ], + "side_conditions": [ + "upright(\"got\") == 2" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"set\") \\ upright(\"set\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"got\") == 2", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"got\") == 2" + } + } + } + }, + { + "id": "benches_runners_eggplant_rewrite_web_demo_set_rs__340_5_MyTxSet_add_rule__set_check_set_get_1m1241_2_is_4__ec2af805dfde5695", + "display_name": "set_check_set_get_1m1241_2_is_4", + "rule_name": "set_check_set_get_1m1241_2_is_4", + "callee": "MyTxSet::add_rule", + "file": "benches/runners/eggplant_rewrite/web_demo_set.rs", + "offset": 10762, + "line": 340, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 10762, + "end": 11271 + }, + "pattern_range": { + "start": 10848, + "end": 11239 + }, + "action_range": { + "start": 11249, + "end": 11264 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "set", + "set" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "got.eq(&4_i64)", + "resolved_text": "got.eq(&4_i64)", + "semantic_text": "got == 4", + "referenced_vars": [], + "range": { + "start": 11214, + "end": 11228 + } + } + ], + "action_effects": [], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "Seen", + "template": "Seen({j})", + "fields": [ + "j" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Seen", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "set_check_set_get_1m1241_2_is_4", + "premises": [ + { + "target_id": "set", + "label": "set", + "plain_source": "upright(\"set\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $]" + }, + { + "target_id": "set", + "label": "set", + "plain_source": "upright(\"set\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $]" + } + ], + "side_conditions": [ + "upright(\"got\") == 4" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"set\") \\ upright(\"set\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"got\") == 4", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"got\") == 4" + } + } + } + }, + { + "id": "benches_runners_eggplant_rewrite_web_demo_set_rs__357_5_MyTxSet_add_rule__set_check_set_get_1m1241_3_is_m1__31ab82abae2c6816", + "display_name": "set_check_set_get_1m1241_3_is_m1", + "rule_name": "set_check_set_get_1m1241_3_is_m1", + "callee": "MyTxSet::add_rule", + "file": "benches/runners/eggplant_rewrite/web_demo_set.rs", + "offset": 11277, + "line": 357, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 11277, + "end": 11788 + }, + "pattern_range": { + "start": 11364, + "end": 11756 + }, + "action_range": { + "start": 11766, + "end": 11781 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "set", + "set" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "got.eq(&-1_i64)", + "resolved_text": "got.eq(&-1_i64)", + "semantic_text": "got == -1", + "referenced_vars": [], + "range": { + "start": 11730, + "end": 11745 + } + } + ], + "action_effects": [], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "Seen", + "template": "Seen({j})", + "fields": [ + "j" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Seen", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "set_check_set_get_1m1241_3_is_m1", + "premises": [ + { + "target_id": "set", + "label": "set", + "plain_source": "upright(\"set\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $]" + }, + { + "target_id": "set", + "label": "set", + "plain_source": "upright(\"set\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $]" + } + ], + "side_conditions": [ + "upright(\"got\") == -1" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"set\") \\ upright(\"set\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"got\") == -1", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"set\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"got\") == -1" + } + } + } + }, + { + "id": "benches_runners_eggplant_rewrite_web_demo_set_rs__415_5_MyTxSet_add_rule__web_demo_set_reify_seed__eb3dd50c9c4a672a", + "display_name": "web_demo_set_reify_seed", + "rule_name": "web_demo_set_reify_seed", + "callee": "MyTxSet::add_rule", + "file": "benches/runners/eggplant_rewrite/web_demo_set.rs", + "offset": 13531, + "line": 415, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 13531, + "end": 14178 + }, + "pattern_range": { + "start": 13607, + "end": 13688 + }, + "action_range": { + "start": 13698, + "end": 14171 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Unit" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@14142:14160", + "bound_var": null, + "source_text": "ctx.set_myset(set)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 14142, + "end": 14160 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "Seen", + "template": "Seen({j})", + "fields": [ + "j" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Seen", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "web_demo_set_reify_seed", + "premises": [ + { + "target_id": "Unit", + "label": "Unit", + "plain_source": "upright(\"Unit\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"Unit\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_eggplant_rewrite_web_demo_set_rs__455_5_MyTxSet_add_rule__web_demo_set_reify0__fe403adda9d017f2", + "display_name": "web_demo_set_reify0", + "rule_name": "web_demo_set_reify0", + "callee": "MyTxSet::add_rule", + "file": "benches/runners/eggplant_rewrite/web_demo_set.rs", + "offset": 14715, + "line": 455, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 14715, + "end": 16166 + }, + "pattern_range": { + "start": 14788, + "end": 15451 + }, + "action_range": { + "start": 15461, + "end": 16159 + } + }, + "nodes": [ + { + "id": "x", + "kind": "query", + "dsl_type": "", + "label": "x: ", + "range": { + "start": 14805, + "end": 14864 + }, + "inputs": [] + }, + { + "id": "y", + "kind": "query", + "dsl_type": "", + "label": "y: ", + "range": { + "start": 14877, + "end": 14931 + }, + "inputs": [] + } + ], + "edges": [], + "roots": [ + "x", + "y", + "x", + "y" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "len.gt(&0_i64)", + "resolved_text": "len.gt(&0_i64)", + "semantic_text": "len > 0", + "referenced_vars": [], + "range": { + "start": 15378, + "end": 15392 + } + }, + { + "id": "constraint_1", + "source_text": "y.handle().eq(&y_expr)", + "resolved_text": "y.handle().eq(&y_expr)", + "semantic_text": "y == y_expr", + "referenced_vars": [ + "y" + ], + "range": { + "start": 15418, + "end": 15440 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@16061:16098", + "bound_var": null, + "source_text": "ctx.insert_func_tbl(\"ISet-get\", &row)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 16061, + "end": 16098 + } + }, + { + "id": "effect_1", + "effect_id": "effect@16116:16134", + "bound_var": null, + "source_text": "ctx.insert_seen(0)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 16116, + "end": 16134 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "Seen", + "template": "Seen({j})", + "fields": [ + "j" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Seen", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "web_demo_set_reify0", + "premises": [ + { + "target_id": "x", + "label": "x: ", + "plain_source": "x", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x $]" + }, + { + "target_id": "y", + "label": "y: ", + "plain_source": "y", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ y $]" + }, + { + "target_id": "x", + "label": "x: ", + "plain_source": "x", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x $]" + }, + { + "target_id": "y", + "label": "y: ", + "plain_source": "y", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ y $]" + } + ], + "side_conditions": [ + "upright(\"len\") > 0", + "y == upright(\"y_expr\")" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(x \\ y \\ x \\ y, upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"len\") > 0 \\ y == upright(\"y_expr\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ y $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ y $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"len\") > 0 \\ y == upright(\"y_expr\")" + } + } + } + }, + { + "id": "benches_runners_eggplant_rewrite_web_demo_set_rs__493_5_MyTxSet_add_rule__web_demo_set_reify_step__a163c9d4fbcf8d4b", + "display_name": "web_demo_set_reify_step", + "rule_name": "web_demo_set_reify_step", + "callee": "MyTxSet::add_rule", + "file": "benches/runners/eggplant_rewrite/web_demo_set.rs", + "offset": 16172, + "line": 493, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 16172, + "end": 17598 + }, + "pattern_range": { + "start": 16249, + "end": 17210 + }, + "action_range": { + "start": 17220, + "end": 17591 + } + }, + "nodes": [ + { + "id": "seen", + "kind": "query", + "dsl_type": "Seen", + "label": "seen: Seen", + "range": { + "start": 16266, + "end": 16291 + }, + "inputs": [] + }, + { + "id": "x", + "kind": "query", + "dsl_type": "", + "label": "x: ", + "range": { + "start": 16304, + "end": 16363 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 16376, + "end": 16430 + }, + "inputs": [] + }, + { + "id": "y", + "kind": "query", + "dsl_type": "", + "label": "y: ", + "range": { + "start": 16443, + "end": 16497 + }, + "inputs": [] + } + ], + "edges": [], + "roots": [ + "seen", + "x", + "i", + "y", + "seen", + "x", + "i", + "y" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "i.handle().eq(&i_expr)", + "resolved_text": "i.handle().eq(&i_expr)", + "semantic_text": "i == i_expr", + "referenced_vars": [ + "i" + ], + "range": { + "start": 17084, + "end": 17106 + } + }, + { + "id": "constraint_1", + "source_text": "i.handle().lt(&len)", + "resolved_text": "i.handle().lt(&len)", + "semantic_text": "i < len", + "referenced_vars": [ + "i" + ], + "range": { + "start": 17132, + "end": 17151 + } + }, + { + "id": "constraint_2", + "source_text": "y.handle().eq(&y_expr)", + "resolved_text": "y.handle().eq(&y_expr)", + "semantic_text": "y == y_expr", + "referenced_vars": [ + "y" + ], + "range": { + "start": 17177, + "end": 17199 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@17493:17530", + "bound_var": null, + "source_text": "ctx.insert_func_tbl(\"ISet-get\", &row)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 17493, + "end": 17530 + } + }, + { + "id": "effect_1", + "effect_id": "effect@17548:17566", + "bound_var": null, + "source_text": "ctx.insert_seen(i)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "i" + ], + "range": { + "start": 17548, + "end": 17566 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "Seen", + "template": "Seen({j})", + "fields": [ + "j" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Seen", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "web_demo_set_reify_step", + "premises": [ + { + "target_id": "seen", + "label": "seen: Seen", + "plain_source": "upright(\"seen\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"seen\") $]" + }, + { + "target_id": "x", + "label": "x: ", + "plain_source": "x", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x $]" + }, + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "y", + "label": "y: ", + "plain_source": "y", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ y $]" + }, + { + "target_id": "seen", + "label": "seen: Seen", + "plain_source": "upright(\"seen\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"seen\") $]" + }, + { + "target_id": "x", + "label": "x: ", + "plain_source": "x", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x $]" + }, + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "y", + "label": "y: ", + "plain_source": "y", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ y $]" + } + ], + "side_conditions": [ + "i == upright(\"i_expr\")", + "i < upright(\"len\")", + "y == upright(\"y_expr\")" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"seen\") \\ x \\ i \\ y \\ upright(\"seen\") \\ x \\ i \\ y, upright(\"no conclusion\")) quad upright(\"if\") quad i == upright(\"i_expr\") \\ i < upright(\"len\") \\ y == upright(\"y_expr\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"seen\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ y $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"seen\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ y $], upright(\"no conclusion\")) quad upright(\"if\") quad i == upright(\"i_expr\") \\ i < upright(\"len\") \\ y == upright(\"y_expr\")" + } + } + } + }, + { + "id": "benches_runners_eggplant_rewrite_web_demo_unify_rs__23_5_MyTxUnify_add_rule__unify_seed__ab46af781ffce7dd", + "display_name": "unify_seed", + "rule_name": "unify_seed", + "callee": "MyTxUnify::add_rule", + "file": "benches/runners/eggplant_rewrite/web_demo_unify.rs", + "offset": 513, + "line": 23, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 513, + "end": 1019 + }, + "pattern_range": { + "start": 578, + "end": 659 + }, + "action_range": { + "start": 669, + "end": 1012 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Unit" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@798:828", + "bound_var": "a", + "source_text": "ctx.insert_var(\"a\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 798, + "end": 828 + } + }, + { + "id": "effect_1", + "effect_id": "effect@855:883", + "bound_var": "mul_aa", + "source_text": "ctx.insert_mul(a.clone(), a)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "a" + ], + "range": { + "start": 855, + "end": 883 + } + }, + { + "id": "effect_2", + "effect_id": "effect@910:962", + "bound_var": "mul_12", + "source_text": "ctx.insert_mul(ctx.insert_lit(1), ctx.insert_lit(2))", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "tmp_0", + "tmp_1" + ], + "range": { + "start": 910, + "end": 962 + } + }, + { + "id": "effect_3", + "effect_id": "effect@925:942", + "bound_var": "tmp_0", + "source_text": "ctx.insert_lit(1)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 925, + "end": 942 + } + }, + { + "id": "effect_4", + "effect_id": "effect@944:961", + "bound_var": "tmp_1", + "source_text": "ctx.insert_lit(2)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 944, + "end": 961 + } + }, + { + "id": "effect_5", + "effect_id": "effect@976:1001", + "bound_var": null, + "source_text": "ctx.union(mul_aa, mul_12)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "mul_12", + "mul_aa" + ], + "range": { + "start": 976, + "end": 1001 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "Mul", + "template": "({l}) * ({r})", + "fields": [ + "l", + "r" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Lit", + "template": "{n}", + "fields": [ + "n" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Mul", + "precedence": 60 + }, + { + "variant_name": "Var", + "precedence": 100 + }, + { + "variant_name": "Lit", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "unify_seed", + "premises": [ + { + "target_id": "Unit", + "label": "Unit", + "plain_source": "upright(\"Unit\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"Unit\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_eggplant_rewrite_web_demo_unify_rs__41_5_MyTxUnify_add_rule__mul_injective__89f6c8d694b1fc4c", + "display_name": "mul_injective", + "rule_name": "mul_injective", + "callee": "MyTxUnify::add_rule", + "file": "benches/runners/eggplant_rewrite/web_demo_unify.rs", + "offset": 1079, + "line": 41, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 1079, + "end": 1856 + }, + "pattern_range": { + "start": 1147, + "end": 1743 + }, + "action_range": { + "start": 1753, + "end": 1849 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "Expr", + "label": "a: Expr", + "range": { + "start": 1164, + "end": 1191 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "Expr", + "label": "b: Expr", + "range": { + "start": 1204, + "end": 1231 + }, + "inputs": [] + }, + { + "id": "c", + "kind": "query_leaf", + "dsl_type": "Expr", + "label": "c: Expr", + "range": { + "start": 1244, + "end": 1271 + }, + "inputs": [] + }, + { + "id": "d", + "kind": "query_leaf", + "dsl_type": "Expr", + "label": "d: Expr", + "range": { + "start": 1284, + "end": 1311 + }, + "inputs": [] + }, + { + "id": "m1", + "kind": "query", + "dsl_type": "Mul", + "label": "m1: Mul", + "range": { + "start": 1324, + "end": 1352 + }, + "inputs": [ + "a", + "b" + ] + }, + { + "id": "m2", + "kind": "query", + "dsl_type": "Mul", + "label": "m2: Mul", + "range": { + "start": 1365, + "end": 1393 + }, + "inputs": [ + "c", + "d" + ] + } + ], + "edges": [ + { + "from": "m1", + "to": "a", + "kind": "operand", + "index": 0 + }, + { + "from": "m1", + "to": "b", + "kind": "operand", + "index": 1 + }, + { + "from": "m2", + "to": "c", + "kind": "operand", + "index": 0 + }, + { + "from": "m2", + "to": "d", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "a", + "b", + "c", + "d", + "_m1", + "_m2", + "a", + "b", + "c", + "d", + "m1", + "m2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "same_mul", + "resolved_text": "m1.handle().eq(&m2.handle())", + "semantic_text": "m1 == m2", + "referenced_vars": [ + "m1", + "m2" + ], + "range": { + "start": 1724, + "end": 1732 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@1778:1801", + "bound_var": null, + "source_text": "ctx.union(pat.a, pat.c)", + "semantic_text": null, + "referenced_pat_vars": [ + "a", + "c" + ], + "referenced_action_vars": [], + "range": { + "start": 1778, + "end": 1801 + } + }, + { + "id": "effect_1", + "effect_id": "effect@1815:1838", + "bound_var": null, + "source_text": "ctx.union(pat.b, pat.d)", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "d" + ], + "referenced_action_vars": [], + "range": { + "start": 1815, + "end": 1838 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "Mul", + "template": "({l}) * ({r})", + "fields": [ + "l", + "r" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Lit", + "template": "{n}", + "fields": [ + "n" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Mul", + "precedence": 60 + }, + { + "variant_name": "Var", + "precedence": 100 + }, + { + "variant_name": "Lit", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "mul_injective", + "premises": [ + { + "target_id": "m1", + "label": "m1: Mul", + "plain_source": "(a) * (b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ a $]) * (#text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + }, + { + "target_id": "m2", + "label": "m2: Mul", + "plain_source": "(c) * (d)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ c $]) * (#text(fill: rgb(\"#5F7A8A\"))[$ d $]) $]" + } + ], + "side_conditions": [ + "m_1 == m_2" + ], + "derivations": [], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_0", + "from": { + "target_id": "a", + "label": "a: Expr", + "plain_source": "a", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ a $]" + }, + "to": { + "target_id": "c", + "label": "c: Expr", + "plain_source": "c", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ c $]" + } + }, + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "b", + "label": "b: Expr", + "plain_source": "b", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ b $]" + }, + "to": { + "target_id": "d", + "label": "d: Expr", + "plain_source": "d", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ d $]" + } + } + ], + "formula_source": { + "plain": "frac((a) * (b) \\ (c) * (d), a arrow.r.double c \\ b arrow.r.double d) quad upright(\"if\") quad m_1 == m_2", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ a $]) * (#text(fill: rgb(\"#5F7A8A\"))[$ b $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ c $]) * (#text(fill: rgb(\"#5F7A8A\"))[$ d $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ a $] arrow.r.double #text(fill: rgb(\"#5F7A8A\"))[$ c $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ b $] arrow.r.double #text(fill: rgb(\"#5F7A8A\"))[$ d $]) quad upright(\"if\") quad m_1 == m_2" + } + } + } + }, + { + "id": "benches_runners_eggplant_rewrite_web_demo_unify_rs__68_5_MyTxUnify_add_rule__lit_eq_mul_panic__de79a3f7dbef28f2", + "display_name": "lit_eq_mul_panic", + "rule_name": "lit_eq_mul_panic", + "callee": "MyTxUnify::add_rule", + "file": "benches/runners/eggplant_rewrite/web_demo_unify.rs", + "offset": 1862, + "line": 68, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 1862, + "end": 2498 + }, + "pattern_range": { + "start": 1933, + "end": 2397 + }, + "action_range": { + "start": 2407, + "end": 2491 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "Expr", + "label": "a: Expr", + "range": { + "start": 1950, + "end": 1977 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "Expr", + "label": "b: Expr", + "range": { + "start": 1990, + "end": 2017 + }, + "inputs": [] + }, + { + "id": "lit", + "kind": "query", + "dsl_type": "Lit", + "label": "lit: Lit", + "range": { + "start": 2030, + "end": 2053 + }, + "inputs": [] + }, + { + "id": "mul", + "kind": "query", + "dsl_type": "Mul", + "label": "mul: Mul", + "range": { + "start": 2066, + "end": 2095 + }, + "inputs": [ + "a", + "b" + ] + } + ], + "edges": [ + { + "from": "mul", + "to": "a", + "kind": "operand", + "index": 0 + }, + { + "from": "mul", + "to": "b", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "a", + "b", + "_lit", + "_mul", + "a", + "b", + "lit", + "mul" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "same_term", + "resolved_text": "lit.handle().eq(&mul.handle())", + "semantic_text": "lit == mul", + "referenced_vars": [ + "lit", + "mul" + ], + "range": { + "start": 2377, + "end": 2386 + } + } + ], + "action_effects": [], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "Mul", + "template": "({l}) * ({r})", + "fields": [ + "l", + "r" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Lit", + "template": "{n}", + "fields": [ + "n" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Mul", + "precedence": 60 + }, + { + "variant_name": "Var", + "precedence": 100 + }, + { + "variant_name": "Lit", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "lit_eq_mul_panic", + "premises": [ + { + "target_id": "lit", + "label": "lit: Lit", + "plain_source": "upright(\"lit\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lit\") $]" + }, + { + "target_id": "mul", + "label": "mul: Mul", + "plain_source": "(a) * (b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ a $]) * (#text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + } + ], + "side_conditions": [ + "upright(\"lit\") == upright(\"mul\")" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"lit\") \\ (a) * (b), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"lit\") == upright(\"mul\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lit\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ a $]) * (#text(fill: rgb(\"#5F7A8A\"))[$ b $]) $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"lit\") == upright(\"mul\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__604_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0000_UF_i_Int_acc_Boolean_j_Int_Boolean_or_acc_Int_eq_i_j__d7a836d9f92b6882", + "display_name": "pao_beta_0000_UF__i_Int_acc_Boolean_j_Int__Boolean___or___acc__Int___eq___i_j__", + "rule_name": "pao_beta_0000_UF__i_Int_acc_Boolean_j_Int__Boolean___or___acc__Int___eq___i_j__", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 29554, + "line": 604, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 29554, + "end": 30427 + }, + "pattern_range": { + "start": 29705, + "end": 30234 + }, + "action_range": { + "start": 30244, + "end": 30420 + } + }, + "nodes": [ + { + "id": "cap0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "cap0: PaoInt", + "range": { + "start": 29722, + "end": 29754 + }, + "inputs": [] + }, + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__i_Int_acc_Boolean_j_Int__Boolean___or___acc__Int___eq___i_j__", + "label": "closure: PaoUF__i_Int_acc_Boolean_j_Int__Boolean___or___acc__Int___eq___i_j__", + "range": { + "start": 29767, + "end": 29864 + }, + "inputs": [ + "cap0" + ] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoBoolean", + "label": "arg0: PaoBoolean", + "range": { + "start": 29877, + "end": 29913 + }, + "inputs": [] + }, + { + "id": "arg1", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg1: PaoInt", + "range": { + "start": 29926, + "end": 29958 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_Boolean_Boolean_Int", + "label": "app: PaoUnstableApp__UnstableFn_Boolean_Boolean_Int", + "range": { + "start": 29971, + "end": 30059 + }, + "inputs": [ + "closure", + "arg0", + "arg1" + ] + } + ], + "edges": [ + { + "from": "closure", + "to": "cap0", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + }, + { + "from": "app", + "to": "arg1", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "cap0", + "arg0", + "arg1", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@30279:30372", + "bound_var": "rhs", + "source_text": "ctx.insert_paoi_int_acc_boolean_j_int_boolean_or_acc_int_eq_i_j(pat.cap0, pat.arg0, pat.arg1)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "arg1", + "cap0" + ], + "referenced_action_vars": [], + "range": { + "start": 30279, + "end": 30372 + } + }, + { + "id": "effect_1", + "effect_id": "effect@30386:30409", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 30386, + "end": 30409 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0000_UF__i_Int_acc_Boolean_j_Int__Boolean___or___acc__Int___eq___i_j__", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Boolean_Boolean_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Boolean_Boolean_Int\")(upright(\"PaoUF__i_Int_acc_Boolean_j_Int__Boolean___or___acc__Int___eq___i_j__\")(cap0), arg0, arg1)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Boolean_Boolean_Int\")(upright(\"PaoUF__i_Int_acc_Boolean_j_Int__Boolean___or___acc__Int___eq___i_j__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoiIntAccBooleanJIntBooleanOrAccIntEqIJ\")(cap0, arg0, arg1)", + "colored_source": "upright(\"PaoiIntAccBooleanJIntBooleanOrAccIntEqIJ\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Boolean_Boolean_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Boolean_Boolean_Int\")(upright(\"PaoUF__i_Int_acc_Boolean_j_Int__Boolean___or___acc__Int___eq___i_j__\")(cap0), arg0, arg1)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Boolean_Boolean_Int\")(upright(\"PaoUF__i_Int_acc_Boolean_j_Int__Boolean___or___acc__Int___eq___i_j__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoiIntAccBooleanJIntBooleanOrAccIntEqIJ\")(cap0, arg0, arg1)", + "colored_source": "upright(\"PaoiIntAccBooleanJIntBooleanOrAccIntEqIJ\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_Boolean_Boolean_Int\")(upright(\"PaoUF__i_Int_acc_Boolean_j_Int__Boolean___or___acc__Int___eq___i_j__\")(cap0), arg0, arg1), upright(\"PaoUnstableApp__UnstableFn_Boolean_Boolean_Int\")(upright(\"PaoUF__i_Int_acc_Boolean_j_Int__Boolean___or___acc__Int___eq___i_j__\")(cap0), arg0, arg1) arrow.r.double upright(\"PaoiIntAccBooleanJIntBooleanOrAccIntEqIJ\")(cap0, arg0, arg1)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_Boolean_Boolean_Int\")(upright(\"PaoUF__i_Int_acc_Boolean_j_Int__Boolean___or___acc__Int___eq___i_j__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $]), upright(\"PaoUnstableApp__UnstableFn_Boolean_Boolean_Int\")(upright(\"PaoUF__i_Int_acc_Boolean_j_Int__Boolean___or___acc__Int___eq___i_j__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $]) arrow.r.double upright(\"PaoiIntAccBooleanJIntBooleanOrAccIntEqIJ\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__621_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0001_UF_value_Value_acc_Boolean_j_Value_Boolean_or_acc_Value_eq_value_j__fe8d835b13fb8ec8", + "display_name": "pao_beta_0001_UF__value_Value_acc_Boolean_j_Value__Boolean___or___acc__Value___eq___value_j__", + "rule_name": "pao_beta_0001_UF__value_Value_acc_Boolean_j_Value__Boolean___or___acc__Value___eq___value_j__", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 30433, + "line": 621, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 30433, + "end": 31360 + }, + "pattern_range": { + "start": 30598, + "end": 31153 + }, + "action_range": { + "start": 31163, + "end": 31353 + } + }, + "nodes": [ + { + "id": "cap0", + "kind": "query_leaf", + "dsl_type": "PaoValue", + "label": "cap0: PaoValue", + "range": { + "start": 30615, + "end": 30649 + }, + "inputs": [] + }, + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__value_Value_acc_Boolean_j_Value__Boolean___or___acc__Value___eq___value_j__", + "label": "closure: PaoUF__value_Value_acc_Boolean_j_Value__Boolean___or___acc__Value___eq___value_j__", + "range": { + "start": 30662, + "end": 30773 + }, + "inputs": [ + "cap0" + ] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoBoolean", + "label": "arg0: PaoBoolean", + "range": { + "start": 30786, + "end": 30822 + }, + "inputs": [] + }, + { + "id": "arg1", + "kind": "query_leaf", + "dsl_type": "PaoValue", + "label": "arg1: PaoValue", + "range": { + "start": 30835, + "end": 30869 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_Boolean_Boolean_Value", + "label": "app: PaoUnstableApp__UnstableFn_Boolean_Boolean_Value", + "range": { + "start": 30882, + "end": 30972 + }, + "inputs": [ + "closure", + "arg0", + "arg1" + ] + } + ], + "edges": [ + { + "from": "closure", + "to": "cap0", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + }, + { + "from": "app", + "to": "arg1", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "cap0", + "arg0", + "arg1", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@31198:31305", + "bound_var": "rhs", + "source_text": "ctx.insert_paovalue_value_acc_boolean_j_value_boolean_or_acc_value_eq_value_j(pat.cap0, pat.arg0, pat.arg1)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "arg1", + "cap0" + ], + "referenced_action_vars": [], + "range": { + "start": 31198, + "end": 31305 + } + }, + { + "id": "effect_1", + "effect_id": "effect@31319:31342", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 31319, + "end": 31342 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0001_UF__value_Value_acc_Boolean_j_Value__Boolean___or___acc__Value___eq___value_j__", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Boolean_Boolean_Value", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Boolean_Boolean_Value\")(upright(\"PaoUF__value_Value_acc_Boolean_j_Value__Boolean___or___acc__Value___eq___value_j__\")(cap0), arg0, arg1)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Boolean_Boolean_Value\")(upright(\"PaoUF__value_Value_acc_Boolean_j_Value__Boolean___or___acc__Value___eq___value_j__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaovalueValueAccBooleanJValueBooleanOrAccValueEqValueJ\")(cap0, arg0, arg1)", + "colored_source": "upright(\"PaovalueValueAccBooleanJValueBooleanOrAccValueEqValueJ\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Boolean_Boolean_Value", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Boolean_Boolean_Value\")(upright(\"PaoUF__value_Value_acc_Boolean_j_Value__Boolean___or___acc__Value___eq___value_j__\")(cap0), arg0, arg1)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Boolean_Boolean_Value\")(upright(\"PaoUF__value_Value_acc_Boolean_j_Value__Boolean___or___acc__Value___eq___value_j__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaovalueValueAccBooleanJValueBooleanOrAccValueEqValueJ\")(cap0, arg0, arg1)", + "colored_source": "upright(\"PaovalueValueAccBooleanJValueBooleanOrAccValueEqValueJ\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_Boolean_Boolean_Value\")(upright(\"PaoUF__value_Value_acc_Boolean_j_Value__Boolean___or___acc__Value___eq___value_j__\")(cap0), arg0, arg1), upright(\"PaoUnstableApp__UnstableFn_Boolean_Boolean_Value\")(upright(\"PaoUF__value_Value_acc_Boolean_j_Value__Boolean___or___acc__Value___eq___value_j__\")(cap0), arg0, arg1) arrow.r.double upright(\"PaovalueValueAccBooleanJValueBooleanOrAccValueEqValueJ\")(cap0, arg0, arg1)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_Boolean_Boolean_Value\")(upright(\"PaoUF__value_Value_acc_Boolean_j_Value__Boolean___or___acc__Value___eq___value_j__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $]), upright(\"PaoUnstableApp__UnstableFn_Boolean_Boolean_Value\")(upright(\"PaoUF__value_Value_acc_Boolean_j_Value__Boolean___or___acc__Value___eq___value_j__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $]) arrow.r.double upright(\"PaovalueValueAccBooleanJValueBooleanOrAccValueEqValueJ\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__638_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0002_UF_axis_TupleInt_i_Int_Boolean_invert_TupleInt_contains_axis_i__956a813a82c50012", + "display_name": "pao_beta_0002_UF__axis_TupleInt_i_Int__Boolean___invert____TupleInt_contains_axis_i__", + "rule_name": "pao_beta_0002_UF__axis_TupleInt_i_Int__Boolean___invert____TupleInt_contains_axis_i__", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 31366, + "line": 638, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 31366, + "end": 32173 + }, + "pattern_range": { + "start": 31523, + "end": 31978 + }, + "action_range": { + "start": 31988, + "end": 32166 + } + }, + "nodes": [ + { + "id": "cap0", + "kind": "query_leaf", + "dsl_type": "PaoTupleInt", + "label": "cap0: PaoTupleInt", + "range": { + "start": 31540, + "end": 31577 + }, + "inputs": [] + }, + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__axis_TupleInt_i_Int__Boolean___invert____TupleInt_contains_axis_i__", + "label": "closure: PaoUF__axis_TupleInt_i_Int__Boolean___invert____TupleInt_contains_axis_i__", + "range": { + "start": 31590, + "end": 31693 + }, + "inputs": [ + "cap0" + ] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg0: PaoInt", + "range": { + "start": 31706, + "end": 31738 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_Boolean_Int", + "label": "app: PaoUnstableApp__UnstableFn_Boolean_Int", + "range": { + "start": 31751, + "end": 31824 + }, + "inputs": [ + "closure", + "arg0" + ] + } + ], + "edges": [ + { + "from": "closure", + "to": "cap0", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cap0", + "arg0", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@32023:32118", + "bound_var": "rhs", + "source_text": "ctx.insert_paoaxis_tuple_int_i_int_boolean_invert_tuple_int_contains_axis_i(pat.cap0, pat.arg0)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "cap0" + ], + "referenced_action_vars": [], + "range": { + "start": 32023, + "end": 32118 + } + }, + { + "id": "effect_1", + "effect_id": "effect@32132:32155", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 32132, + "end": 32155 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0002_UF__axis_TupleInt_i_Int__Boolean___invert____TupleInt_contains_axis_i__", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Boolean_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Boolean_Int\")(upright(\"PaoUF__axis_TupleInt_i_Int__Boolean___invert____TupleInt_contains_axis_i__\")(cap0), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Boolean_Int\")(upright(\"PaoUF__axis_TupleInt_i_Int__Boolean___invert____TupleInt_contains_axis_i__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoaxisTupleIntIIntBooleanInvertTupleIntContainsAxisI\")(cap0, arg0)", + "colored_source": "upright(\"PaoaxisTupleIntIIntBooleanInvertTupleIntContainsAxisI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Boolean_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Boolean_Int\")(upright(\"PaoUF__axis_TupleInt_i_Int__Boolean___invert____TupleInt_contains_axis_i__\")(cap0), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Boolean_Int\")(upright(\"PaoUF__axis_TupleInt_i_Int__Boolean___invert____TupleInt_contains_axis_i__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoaxisTupleIntIIntBooleanInvertTupleIntContainsAxisI\")(cap0, arg0)", + "colored_source": "upright(\"PaoaxisTupleIntIIntBooleanInvertTupleIntContainsAxisI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_Boolean_Int\")(upright(\"PaoUF__axis_TupleInt_i_Int__Boolean___invert____TupleInt_contains_axis_i__\")(cap0), arg0), upright(\"PaoUnstableApp__UnstableFn_Boolean_Int\")(upright(\"PaoUF__axis_TupleInt_i_Int__Boolean___invert____TupleInt_contains_axis_i__\")(cap0), arg0) arrow.r.double upright(\"PaoaxisTupleIntIIntBooleanInvertTupleIntContainsAxisI\")(cap0, arg0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_Boolean_Int\")(upright(\"PaoUF__axis_TupleInt_i_Int__Boolean___invert____TupleInt_contains_axis_i__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]), upright(\"PaoUnstableApp__UnstableFn_Boolean_Int\")(upright(\"PaoUF__axis_TupleInt_i_Int__Boolean___invert____TupleInt_contains_axis_i__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]) arrow.r.double upright(\"PaoaxisTupleIntIIntBooleanInvertTupleIntContainsAxisI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__654_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0003_UF_axis_TupleInt_i_Int_TupleInt_contains_axis_i__a1bca63a7d2df9b7", + "display_name": "pao_beta_0003_UF__axis_TupleInt_i_Int__TupleInt_contains_axis_i_", + "rule_name": "pao_beta_0003_UF__axis_TupleInt_i_Int__TupleInt_contains_axis_i_", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 32179, + "line": 654, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 32179, + "end": 32929 + }, + "pattern_range": { + "start": 32315, + "end": 32749 + }, + "action_range": { + "start": 32759, + "end": 32922 + } + }, + "nodes": [ + { + "id": "cap0", + "kind": "query_leaf", + "dsl_type": "PaoTupleInt", + "label": "cap0: PaoTupleInt", + "range": { + "start": 32332, + "end": 32369 + }, + "inputs": [] + }, + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__axis_TupleInt_i_Int__TupleInt_contains_axis_i_", + "label": "closure: PaoUF__axis_TupleInt_i_Int__TupleInt_contains_axis_i_", + "range": { + "start": 32382, + "end": 32464 + }, + "inputs": [ + "cap0" + ] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg0: PaoInt", + "range": { + "start": 32477, + "end": 32509 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_Boolean_Int", + "label": "app: PaoUnstableApp__UnstableFn_Boolean_Int", + "range": { + "start": 32522, + "end": 32595 + }, + "inputs": [ + "closure", + "arg0" + ] + } + ], + "edges": [ + { + "from": "closure", + "to": "cap0", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cap0", + "arg0", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@32794:32874", + "bound_var": "rhs", + "source_text": "ctx.insert_paoaxis_tuple_int_i_int_tuple_int_contains_axis_i(pat.cap0, pat.arg0)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "cap0" + ], + "referenced_action_vars": [], + "range": { + "start": 32794, + "end": 32874 + } + }, + { + "id": "effect_1", + "effect_id": "effect@32888:32911", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 32888, + "end": 32911 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0003_UF__axis_TupleInt_i_Int__TupleInt_contains_axis_i_", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Boolean_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Boolean_Int\")(upright(\"PaoUF__axis_TupleInt_i_Int__TupleInt_contains_axis_i_\")(cap0), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Boolean_Int\")(upright(\"PaoUF__axis_TupleInt_i_Int__TupleInt_contains_axis_i_\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoaxisTupleIntIIntTupleIntContainsAxisI\")(cap0, arg0)", + "colored_source": "upright(\"PaoaxisTupleIntIIntTupleIntContainsAxisI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Boolean_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Boolean_Int\")(upright(\"PaoUF__axis_TupleInt_i_Int__TupleInt_contains_axis_i_\")(cap0), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Boolean_Int\")(upright(\"PaoUF__axis_TupleInt_i_Int__TupleInt_contains_axis_i_\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoaxisTupleIntIIntTupleIntContainsAxisI\")(cap0, arg0)", + "colored_source": "upright(\"PaoaxisTupleIntIIntTupleIntContainsAxisI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_Boolean_Int\")(upright(\"PaoUF__axis_TupleInt_i_Int__TupleInt_contains_axis_i_\")(cap0), arg0), upright(\"PaoUnstableApp__UnstableFn_Boolean_Int\")(upright(\"PaoUF__axis_TupleInt_i_Int__TupleInt_contains_axis_i_\")(cap0), arg0) arrow.r.double upright(\"PaoaxisTupleIntIIntTupleIntContainsAxisI\")(cap0, arg0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_Boolean_Int\")(upright(\"PaoUF__axis_TupleInt_i_Int__TupleInt_contains_axis_i_\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]), upright(\"PaoUnstableApp__UnstableFn_Boolean_Int\")(upright(\"PaoUF__axis_TupleInt_i_Int__TupleInt_contains_axis_i_\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]) arrow.r.double upright(\"PaoaxisTupleIntIIntTupleIntContainsAxisI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__670_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0004_UF_indices_TupleInt_i_Int_Boolean_invert_TupleInt_contains_indices_i__20a35db0a6189d04", + "display_name": "pao_beta_0004_UF__indices_TupleInt_i_Int__Boolean___invert____TupleInt_contains_indices_i__", + "rule_name": "pao_beta_0004_UF__indices_TupleInt_i_Int__Boolean___invert____TupleInt_contains_indices_i__", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 32935, + "line": 670, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 32935, + "end": 33760 + }, + "pattern_range": { + "start": 33098, + "end": 33559 + }, + "action_range": { + "start": 33569, + "end": 33753 + } + }, + "nodes": [ + { + "id": "cap0", + "kind": "query_leaf", + "dsl_type": "PaoTupleInt", + "label": "cap0: PaoTupleInt", + "range": { + "start": 33115, + "end": 33152 + }, + "inputs": [] + }, + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__indices_TupleInt_i_Int__Boolean___invert____TupleInt_contains_indices_i__", + "label": "closure: PaoUF__indices_TupleInt_i_Int__Boolean___invert____TupleInt_contains_indices_i__", + "range": { + "start": 33165, + "end": 33274 + }, + "inputs": [ + "cap0" + ] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg0: PaoInt", + "range": { + "start": 33287, + "end": 33319 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_Boolean_Int", + "label": "app: PaoUnstableApp__UnstableFn_Boolean_Int", + "range": { + "start": 33332, + "end": 33405 + }, + "inputs": [ + "closure", + "arg0" + ] + } + ], + "edges": [ + { + "from": "closure", + "to": "cap0", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cap0", + "arg0", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@33604:33705", + "bound_var": "rhs", + "source_text": "ctx.insert_paoindices_tuple_int_i_int_boolean_invert_tuple_int_contains_indices_i(pat.cap0, pat.arg0)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "cap0" + ], + "referenced_action_vars": [], + "range": { + "start": 33604, + "end": 33705 + } + }, + { + "id": "effect_1", + "effect_id": "effect@33719:33742", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 33719, + "end": 33742 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0004_UF__indices_TupleInt_i_Int__Boolean___invert____TupleInt_contains_indices_i__", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Boolean_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Boolean_Int\")(upright(\"PaoUF__indices_TupleInt_i_Int__Boolean___invert____TupleInt_contains_indices_i__\")(cap0), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Boolean_Int\")(upright(\"PaoUF__indices_TupleInt_i_Int__Boolean___invert____TupleInt_contains_indices_i__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoindicesTupleIntIIntBooleanInvertTupleIntContainsIndicesI\")(cap0, arg0)", + "colored_source": "upright(\"PaoindicesTupleIntIIntBooleanInvertTupleIntContainsIndicesI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Boolean_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Boolean_Int\")(upright(\"PaoUF__indices_TupleInt_i_Int__Boolean___invert____TupleInt_contains_indices_i__\")(cap0), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Boolean_Int\")(upright(\"PaoUF__indices_TupleInt_i_Int__Boolean___invert____TupleInt_contains_indices_i__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoindicesTupleIntIIntBooleanInvertTupleIntContainsIndicesI\")(cap0, arg0)", + "colored_source": "upright(\"PaoindicesTupleIntIIntBooleanInvertTupleIntContainsIndicesI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_Boolean_Int\")(upright(\"PaoUF__indices_TupleInt_i_Int__Boolean___invert____TupleInt_contains_indices_i__\")(cap0), arg0), upright(\"PaoUnstableApp__UnstableFn_Boolean_Int\")(upright(\"PaoUF__indices_TupleInt_i_Int__Boolean___invert____TupleInt_contains_indices_i__\")(cap0), arg0) arrow.r.double upright(\"PaoindicesTupleIntIIntBooleanInvertTupleIntContainsIndicesI\")(cap0, arg0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_Boolean_Int\")(upright(\"PaoUF__indices_TupleInt_i_Int__Boolean___invert____TupleInt_contains_indices_i__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]), upright(\"PaoUnstableApp__UnstableFn_Boolean_Int\")(upright(\"PaoUF__indices_TupleInt_i_Int__Boolean___invert____TupleInt_contains_indices_i__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]) arrow.r.double upright(\"PaoindicesTupleIntIIntBooleanInvertTupleIntContainsIndicesI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__686_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0005_UF_dims_TupleInt_i_Int_TupleInt_getitem_dims_i__89b5bc815758fe36", + "display_name": "pao_beta_0005_UF__dims_TupleInt_i_Int__TupleInt___getitem___dims_i_", + "rule_name": "pao_beta_0005_UF__dims_TupleInt_i_Int__TupleInt___getitem___dims_i_", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 33766, + "line": 686, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 33766, + "end": 34513 + }, + "pattern_range": { + "start": 33905, + "end": 34334 + }, + "action_range": { + "start": 34344, + "end": 34506 + } + }, + "nodes": [ + { + "id": "cap0", + "kind": "query_leaf", + "dsl_type": "PaoTupleInt", + "label": "cap0: PaoTupleInt", + "range": { + "start": 33922, + "end": 33959 + }, + "inputs": [] + }, + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__dims_TupleInt_i_Int__TupleInt___getitem___dims_i_", + "label": "closure: PaoUF__dims_TupleInt_i_Int__TupleInt___getitem___dims_i_", + "range": { + "start": 33972, + "end": 34057 + }, + "inputs": [ + "cap0" + ] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg0: PaoInt", + "range": { + "start": 34070, + "end": 34102 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_Int_Int", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int", + "range": { + "start": 34115, + "end": 34184 + }, + "inputs": [ + "closure", + "arg0" + ] + } + ], + "edges": [ + { + "from": "closure", + "to": "cap0", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cap0", + "arg0", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@34379:34458", + "bound_var": "rhs", + "source_text": "ctx.insert_paodims_tuple_int_i_int_tuple_int_getitem_dims_i(pat.cap0, pat.arg0)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "cap0" + ], + "referenced_action_vars": [], + "range": { + "start": 34379, + "end": 34458 + } + }, + { + "id": "effect_1", + "effect_id": "effect@34472:34495", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 34472, + "end": 34495 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0005_UF__dims_TupleInt_i_Int__TupleInt___getitem___dims_i_", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__dims_TupleInt_i_Int__TupleInt___getitem___dims_i_\")(cap0), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__dims_TupleInt_i_Int__TupleInt___getitem___dims_i_\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaodimsTupleIntIIntTupleIntGetitemDimsI\")(cap0, arg0)", + "colored_source": "upright(\"PaodimsTupleIntIIntTupleIntGetitemDimsI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__dims_TupleInt_i_Int__TupleInt___getitem___dims_i_\")(cap0), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__dims_TupleInt_i_Int__TupleInt___getitem___dims_i_\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaodimsTupleIntIIntTupleIntGetitemDimsI\")(cap0, arg0)", + "colored_source": "upright(\"PaodimsTupleIntIIntTupleIntGetitemDimsI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__dims_TupleInt_i_Int__TupleInt___getitem___dims_i_\")(cap0), arg0), upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__dims_TupleInt_i_Int__TupleInt___getitem___dims_i_\")(cap0), arg0) arrow.r.double upright(\"PaodimsTupleIntIIntTupleIntGetitemDimsI\")(cap0, arg0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__dims_TupleInt_i_Int__TupleInt___getitem___dims_i_\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]), upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__dims_TupleInt_i_Int__TupleInt___getitem___dims_i_\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]) arrow.r.double upright(\"PaodimsTupleIntIIntTupleIntGetitemDimsI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__702_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0006_UF_f_UnstableFn_Int_Int_self_TupleInt_i_Int_unstable_app_f_TupleInt_getitem_self_i__d3919cf61ddec562", + "display_name": "pao_beta_0006_UF__f_UnstableFn_Int_Int_self_TupleInt_i_Int__unstable_app_f__TupleInt___getitem___self_i__", + "rule_name": "pao_beta_0006_UF__f_UnstableFn_Int_Int_self_TupleInt_i_Int__unstable_app_f__TupleInt___getitem___self_i__", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 34519, + "line": 702, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 34519, + "end": 35485 + }, + "pattern_range": { + "start": 34696, + "end": 35259 + }, + "action_range": { + "start": 35269, + "end": 35478 + } + }, + "nodes": [ + { + "id": "cap0", + "kind": "query_leaf", + "dsl_type": "PaoUnstableFn_Int_Int", + "label": "cap0: PaoUnstableFn_Int_Int", + "range": { + "start": 34713, + "end": 34760 + }, + "inputs": [] + }, + { + "id": "cap1", + "kind": "query_leaf", + "dsl_type": "PaoTupleInt", + "label": "cap1: PaoTupleInt", + "range": { + "start": 34773, + "end": 34810 + }, + "inputs": [] + }, + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__f_UnstableFn_Int_Int_self_TupleInt_i_Int__unstable_app_f__TupleInt___getitem___self_i__", + "label": "closure: PaoUF__f_UnstableFn_Int_Int_self_TupleInt_i_Int__unstable_app_f__TupleInt___getitem___self_i__", + "range": { + "start": 34823, + "end": 34953 + }, + "inputs": [ + "cap0", + "cap1" + ] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg0: PaoInt", + "range": { + "start": 34966, + "end": 34998 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_Int_Int", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int", + "range": { + "start": 35011, + "end": 35080 + }, + "inputs": [ + "closure", + "arg0" + ] + } + ], + "edges": [ + { + "from": "closure", + "to": "cap0", + "kind": "operand", + "index": 0 + }, + { + "from": "closure", + "to": "cap1", + "kind": "operand", + "index": 1 + }, + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cap0", + "cap1", + "arg0", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@35304:35430", + "bound_var": "rhs", + "source_text": "ctx.insert_paof_unstable_fn_int_int_self_tuple_int_i_int_unstable_app_f_tuple_int_getitem_self_i(pat.cap0, pat.cap1, pat.arg0)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "cap0", + "cap1" + ], + "referenced_action_vars": [], + "range": { + "start": 35304, + "end": 35430 + } + }, + { + "id": "effect_1", + "effect_id": "effect@35444:35467", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 35444, + "end": 35467 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0006_UF__f_UnstableFn_Int_Int_self_TupleInt_i_Int__unstable_app_f__TupleInt___getitem___self_i__", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__f_UnstableFn_Int_Int_self_TupleInt_i_Int__unstable_app_f__TupleInt___getitem___self_i__\")(cap0, cap1), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__f_UnstableFn_Int_Int_self_TupleInt_i_Int__unstable_app_f__TupleInt___getitem___self_i__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaofUnstableFnIntIntSelfTupleIntIIntUnstableAppFTupleIntGetitemSelfI\")(cap0, cap1, arg0)", + "colored_source": "upright(\"PaofUnstableFnIntIntSelfTupleIntIIntUnstableAppFTupleIntGetitemSelfI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__f_UnstableFn_Int_Int_self_TupleInt_i_Int__unstable_app_f__TupleInt___getitem___self_i__\")(cap0, cap1), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__f_UnstableFn_Int_Int_self_TupleInt_i_Int__unstable_app_f__TupleInt___getitem___self_i__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaofUnstableFnIntIntSelfTupleIntIIntUnstableAppFTupleIntGetitemSelfI\")(cap0, cap1, arg0)", + "colored_source": "upright(\"PaofUnstableFnIntIntSelfTupleIntIIntUnstableAppFTupleIntGetitemSelfI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__f_UnstableFn_Int_Int_self_TupleInt_i_Int__unstable_app_f__TupleInt___getitem___self_i__\")(cap0, cap1), arg0), upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__f_UnstableFn_Int_Int_self_TupleInt_i_Int__unstable_app_f__TupleInt___getitem___self_i__\")(cap0, cap1), arg0) arrow.r.double upright(\"PaofUnstableFnIntIntSelfTupleIntIIntUnstableAppFTupleIntGetitemSelfI\")(cap0, cap1, arg0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__f_UnstableFn_Int_Int_self_TupleInt_i_Int__unstable_app_f__TupleInt___getitem___self_i__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]), upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__f_UnstableFn_Int_Int_self_TupleInt_i_Int__unstable_app_f__TupleInt___getitem___self_i__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]) arrow.r.double upright(\"PaofUnstableFnIntIntSelfTupleIntIIntUnstableAppFTupleIntGetitemSelfI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__719_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0007_UF_f_UnstableFn_Int_TupleInt_self_TupleTupleInt_i_Int_unstable_app_f_TupleTupleInt_getitem_self_i__7cf854c3e8dfac3b", + "display_name": "pao_beta_0007_UF__f_UnstableFn_Int_TupleInt_self_TupleTupleInt_i_Int__unstable_app_f__TupleTupleInt___getitem___self_i__", + "rule_name": "pao_beta_0007_UF__f_UnstableFn_Int_TupleInt_self_TupleTupleInt_i_Int__unstable_app_f__TupleTupleInt___getitem___self_i__", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 35491, + "line": 719, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 35491, + "end": 36525 + }, + "pattern_range": { + "start": 35683, + "end": 36281 + }, + "action_range": { + "start": 36291, + "end": 36518 + } + }, + "nodes": [ + { + "id": "cap0", + "kind": "query_leaf", + "dsl_type": "PaoUnstableFn_Int_TupleInt", + "label": "cap0: PaoUnstableFn_Int_TupleInt", + "range": { + "start": 35700, + "end": 35752 + }, + "inputs": [] + }, + { + "id": "cap1", + "kind": "query_leaf", + "dsl_type": "PaoTupleTupleInt", + "label": "cap1: PaoTupleTupleInt", + "range": { + "start": 35765, + "end": 35807 + }, + "inputs": [] + }, + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__f_UnstableFn_Int_TupleInt_self_TupleTupleInt_i_Int__unstable_app_f__TupleTupleInt___getitem___self_i__", + "label": "closure: PaoUF__f_UnstableFn_Int_TupleInt_self_TupleTupleInt_i_Int__unstable_app_f__TupleTupleInt___getitem___self_i__", + "range": { + "start": 35820, + "end": 35965 + }, + "inputs": [ + "cap0", + "cap1" + ] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg0: PaoInt", + "range": { + "start": 35978, + "end": 36010 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_Int_Int", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int", + "range": { + "start": 36023, + "end": 36092 + }, + "inputs": [ + "closure", + "arg0" + ] + } + ], + "edges": [ + { + "from": "closure", + "to": "cap0", + "kind": "operand", + "index": 0 + }, + { + "from": "closure", + "to": "cap1", + "kind": "operand", + "index": 1 + }, + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cap0", + "cap1", + "arg0", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@36326:36470", + "bound_var": "rhs", + "source_text": "ctx.insert_paof_unstable_fn_int_tuple_int_self_tuple_tuple_int_i_int_unstable_app_f_tuple_tuple_int_getitem_self_i(pat.cap0, pat.cap1, pat.arg0)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "cap0", + "cap1" + ], + "referenced_action_vars": [], + "range": { + "start": 36326, + "end": 36470 + } + }, + { + "id": "effect_1", + "effect_id": "effect@36484:36507", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 36484, + "end": 36507 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0007_UF__f_UnstableFn_Int_TupleInt_self_TupleTupleInt_i_Int__unstable_app_f__TupleTupleInt___getitem___self_i__", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__f_UnstableFn_Int_TupleInt_self_TupleTupleInt_i_Int__unstable_app_f__TupleTupleInt___getitem___self_i__\")(cap0, cap1), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__f_UnstableFn_Int_TupleInt_self_TupleTupleInt_i_Int__unstable_app_f__TupleTupleInt___getitem___self_i__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaofUnstableFnIntTupleIntSelfTupleTupleIntIIntUnstableAppFTupleTupleIntGetitemSelfI\")(cap0, cap1, arg0)", + "colored_source": "upright(\"PaofUnstableFnIntTupleIntSelfTupleTupleIntIIntUnstableAppFTupleTupleIntGetitemSelfI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__f_UnstableFn_Int_TupleInt_self_TupleTupleInt_i_Int__unstable_app_f__TupleTupleInt___getitem___self_i__\")(cap0, cap1), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__f_UnstableFn_Int_TupleInt_self_TupleTupleInt_i_Int__unstable_app_f__TupleTupleInt___getitem___self_i__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaofUnstableFnIntTupleIntSelfTupleTupleIntIIntUnstableAppFTupleTupleIntGetitemSelfI\")(cap0, cap1, arg0)", + "colored_source": "upright(\"PaofUnstableFnIntTupleIntSelfTupleTupleIntIIntUnstableAppFTupleTupleIntGetitemSelfI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__f_UnstableFn_Int_TupleInt_self_TupleTupleInt_i_Int__unstable_app_f__TupleTupleInt___getitem___self_i__\")(cap0, cap1), arg0), upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__f_UnstableFn_Int_TupleInt_self_TupleTupleInt_i_Int__unstable_app_f__TupleTupleInt___getitem___self_i__\")(cap0, cap1), arg0) arrow.r.double upright(\"PaofUnstableFnIntTupleIntSelfTupleTupleIntIIntUnstableAppFTupleTupleIntGetitemSelfI\")(cap0, cap1, arg0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__f_UnstableFn_Int_TupleInt_self_TupleTupleInt_i_Int__unstable_app_f__TupleTupleInt___getitem___self_i__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]), upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__f_UnstableFn_Int_TupleInt_self_TupleTupleInt_i_Int__unstable_app_f__TupleTupleInt___getitem___self_i__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]) arrow.r.double upright(\"PaofUnstableFnIntTupleIntSelfTupleTupleIntIIntUnstableAppFTupleTupleIntGetitemSelfI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__736_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0008_UF_i_Int_Int_i__6036cafb840f6a3f", + "display_name": "pao_beta_0008_UF__i_Int___Int_i", + "rule_name": "pao_beta_0008_UF__i_Int___Int_i", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 36531, + "line": 736, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 36531, + "end": 37162 + }, + "pattern_range": { + "start": 36634, + "end": 37017 + }, + "action_range": { + "start": 37027, + "end": 37155 + } + }, + "nodes": [ + { + "id": "cap0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "cap0: PaoInt", + "range": { + "start": 36651, + "end": 36683 + }, + "inputs": [] + }, + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__i_Int___Int_i", + "label": "closure: PaoUF__i_Int___Int_i", + "range": { + "start": 36696, + "end": 36745 + }, + "inputs": [ + "cap0" + ] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg0: PaoInt", + "range": { + "start": 36758, + "end": 36790 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_Int_Int", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int", + "range": { + "start": 36803, + "end": 36872 + }, + "inputs": [ + "closure", + "arg0" + ] + } + ], + "edges": [ + { + "from": "closure", + "to": "cap0", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cap0", + "arg0", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@37062:37107", + "bound_var": "rhs", + "source_text": "ctx.insert_paoi_int_int_i(pat.cap0, pat.arg0)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "cap0" + ], + "referenced_action_vars": [], + "range": { + "start": 37062, + "end": 37107 + } + }, + { + "id": "effect_1", + "effect_id": "effect@37121:37144", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 37121, + "end": 37144 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0008_UF__i_Int___Int_i", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__i_Int___Int_i\")(cap0), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__i_Int___Int_i\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoiIntIntI\")(cap0, arg0)", + "colored_source": "upright(\"PaoiIntIntI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__i_Int___Int_i\")(cap0), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__i_Int___Int_i\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoiIntIntI\")(cap0, arg0)", + "colored_source": "upright(\"PaoiIntIntI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__i_Int___Int_i\")(cap0), arg0), upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__i_Int___Int_i\")(cap0), arg0) arrow.r.double upright(\"PaoiIntIntI\")(cap0, arg0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__i_Int___Int_i\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]), upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__i_Int___Int_i\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]) arrow.r.double upright(\"PaoiIntIntI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__752_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0009_UF_i_Int_i__d564850fcfcb7e2a", + "display_name": "pao_beta_0009_UF__i_Int_i", + "rule_name": "pao_beta_0009_UF__i_Int_i", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 37168, + "line": 752, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 37168, + "end": 37709 + }, + "pattern_range": { + "start": 37265, + "end": 37578 + }, + "action_range": { + "start": 37588, + "end": 37702 + } + }, + "nodes": [ + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__i_Int_i", + "label": "closure: PaoUF__i_Int_i", + "range": { + "start": 37282, + "end": 37320 + }, + "inputs": [] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg0: PaoInt", + "range": { + "start": 37333, + "end": 37365 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_Int_Int", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int", + "range": { + "start": 37378, + "end": 37447 + }, + "inputs": [ + "closure", + "arg0" + ] + } + ], + "edges": [ + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "arg0", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@37623:37654", + "bound_var": "rhs", + "source_text": "ctx.insert_paoi_int_i(pat.arg0)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0" + ], + "referenced_action_vars": [], + "range": { + "start": 37623, + "end": 37654 + } + }, + { + "id": "effect_1", + "effect_id": "effect@37668:37691", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 37668, + "end": 37691 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0009_UF__i_Int_i", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"closure\"), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoiIntI\")(arg0)", + "colored_source": "upright(\"PaoiIntI\")(#text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"closure\"), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoiIntI\")(arg0)", + "colored_source": "upright(\"PaoiIntI\")(#text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"closure\"), arg0), upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"closure\"), arg0) arrow.r.double upright(\"PaoiIntI\")(arg0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]), upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]) arrow.r.double upright(\"PaoiIntI\")(#text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__767_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0010_UF_i_Int_self_TupleTupleInt_j_Int_TupleInt_getitem_TupleTupleInt_getitem_self_j_Int_mod_Int_floordiv_i_TupleInt_product_TupleTupleInt_map_int_TupleTupleInt_drop_self_Int_add_j_Int_init_1_unstable_fn_x_TupleInt_TupleInt_length_x_TupleInt_length_TupleTupleInt_getitem_self_j__e196e6ab8bd19823", + "display_name": "pao_beta_0010_UF__i_Int_self_TupleTupleInt_j_Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable_fn__x_TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j____", + "rule_name": "pao_beta_0010_UF__i_Int_self_TupleTupleInt_j_Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable_fn__x_TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j____", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 37715, + "line": 767, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 37715, + "end": 39339 + }, + "pattern_range": { + "start": 38130, + "end": 38911 + }, + "action_range": { + "start": 38921, + "end": 39332 + } + }, + "nodes": [ + { + "id": "cap0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "cap0: PaoInt", + "range": { + "start": 38147, + "end": 38179 + }, + "inputs": [] + }, + { + "id": "cap1", + "kind": "query_leaf", + "dsl_type": "PaoTupleTupleInt", + "label": "cap1: PaoTupleTupleInt", + "range": { + "start": 38192, + "end": 38234 + }, + "inputs": [] + }, + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__i_Int_self_TupleTupleInt_j_Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable_fn__x_TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j____", + "label": "closure: PaoUF__i_Int_self_TupleTupleInt_j_Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable_fn__x_TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j____", + "range": { + "start": 38247, + "end": 38615 + }, + "inputs": [ + "cap0", + "cap1" + ] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg0: PaoInt", + "range": { + "start": 38628, + "end": 38660 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_Int_Int", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int", + "range": { + "start": 38673, + "end": 38742 + }, + "inputs": [ + "closure", + "arg0" + ] + } + ], + "edges": [ + { + "from": "closure", + "to": "cap0", + "kind": "operand", + "index": 0 + }, + { + "from": "closure", + "to": "cap1", + "kind": "operand", + "index": 1 + }, + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cap0", + "cap1", + "arg0", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@38956:39284", + "bound_var": "rhs", + "source_text": "ctx.insert_paoi_int_self_tuple_tuple_int_j_int_tuple_int_getitem_tuple_tuple_int_getitem_self_j_int_mod_int_floordiv_i_tuple_int_product_tuple_tuple_int_map_int_tuple_tuple_int_drop_self_int_add_j_int_init_1_unstable_fn_x_tuple_int_tuple_int_length_x_tuple_int_length_tuple_tuple_int_getitem_self_j(pat.cap0, pat.cap1, pat.arg0)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "cap0", + "cap1" + ], + "referenced_action_vars": [], + "range": { + "start": 38956, + "end": 39284 + } + }, + { + "id": "effect_1", + "effect_id": "effect@39298:39321", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 39298, + "end": 39321 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0010_UF__i_Int_self_TupleTupleInt_j_Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable_fn__x_TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j____", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__i_Int_self_TupleTupleInt_j_Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable_fn__x_TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j____\")(cap0, cap1), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__i_Int_self_TupleTupleInt_j_Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable_fn__x_TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j____\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoiIntSelfTupleTupleIntJIntTupleIntGetitemTupleTupleIntGetitemSelfJIntModIntFloordivITupleIntProductTupleTupleIntMapIntTupleTupleIntDropSelfIntAddJIntInit1UnstableFnXTupleIntTupleIntLengthXTupleIntLengthTupleTupleIntGetitemSelfJ\")(cap0, cap1, arg0)", + "colored_source": "upright(\"PaoiIntSelfTupleTupleIntJIntTupleIntGetitemTupleTupleIntGetitemSelfJIntModIntFloordivITupleIntProductTupleTupleIntMapIntTupleTupleIntDropSelfIntAddJIntInit1UnstableFnXTupleIntTupleIntLengthXTupleIntLengthTupleTupleIntGetitemSelfJ\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__i_Int_self_TupleTupleInt_j_Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable_fn__x_TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j____\")(cap0, cap1), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__i_Int_self_TupleTupleInt_j_Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable_fn__x_TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j____\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoiIntSelfTupleTupleIntJIntTupleIntGetitemTupleTupleIntGetitemSelfJIntModIntFloordivITupleIntProductTupleTupleIntMapIntTupleTupleIntDropSelfIntAddJIntInit1UnstableFnXTupleIntTupleIntLengthXTupleIntLengthTupleTupleIntGetitemSelfJ\")(cap0, cap1, arg0)", + "colored_source": "upright(\"PaoiIntSelfTupleTupleIntJIntTupleIntGetitemTupleTupleIntGetitemSelfJIntModIntFloordivITupleIntProductTupleTupleIntMapIntTupleTupleIntDropSelfIntAddJIntInit1UnstableFnXTupleIntTupleIntLengthXTupleIntLengthTupleTupleIntGetitemSelfJ\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__i_Int_self_TupleTupleInt_j_Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable_fn__x_TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j____\")(cap0, cap1), arg0), upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__i_Int_self_TupleTupleInt_j_Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable_fn__x_TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j____\")(cap0, cap1), arg0) arrow.r.double upright(\"PaoiIntSelfTupleTupleIntJIntTupleIntGetitemTupleTupleIntGetitemSelfJIntModIntFloordivITupleIntProductTupleTupleIntMapIntTupleTupleIntDropSelfIntAddJIntInit1UnstableFnXTupleIntTupleIntLengthXTupleIntLengthTupleTupleIntGetitemSelfJ\")(cap0, cap1, arg0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__i_Int_self_TupleTupleInt_j_Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable_fn__x_TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j____\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]), upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__i_Int_self_TupleTupleInt_j_Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable_fn__x_TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j____\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]) arrow.r.double upright(\"PaoiIntSelfTupleTupleIntJIntTupleIntGetitemTupleTupleIntGetitemSelfJIntModIntFloordivITupleIntProductTupleTupleIntMapIntTupleTupleIntDropSelfIntAddJIntInit1UnstableFnXTupleIntTupleIntLengthXTupleIntLengthTupleTupleIntGetitemSelfJ\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__784_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0011_UF_n_Int_self_TupleInt_i_Int_TupleInt_getitem_self_Int_add_i_n__18d35a33dfca5a14", + "display_name": "pao_beta_0011_UF__n_Int_self_TupleInt_i_Int__TupleInt___getitem___self__Int___add___i_n__", + "rule_name": "pao_beta_0011_UF__n_Int_self_TupleInt_i_Int__TupleInt___getitem___self__Int___add___i_n__", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 39345, + "line": 784, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 39345, + "end": 40228 + }, + "pattern_range": { + "start": 39506, + "end": 40023 + }, + "action_range": { + "start": 40033, + "end": 40221 + } + }, + "nodes": [ + { + "id": "cap0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "cap0: PaoInt", + "range": { + "start": 39523, + "end": 39555 + }, + "inputs": [] + }, + { + "id": "cap1", + "kind": "query_leaf", + "dsl_type": "PaoTupleInt", + "label": "cap1: PaoTupleInt", + "range": { + "start": 39568, + "end": 39605 + }, + "inputs": [] + }, + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__n_Int_self_TupleInt_i_Int__TupleInt___getitem___self__Int___add___i_n__", + "label": "closure: PaoUF__n_Int_self_TupleInt_i_Int__TupleInt___getitem___self__Int___add___i_n__", + "range": { + "start": 39618, + "end": 39732 + }, + "inputs": [ + "cap0", + "cap1" + ] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg0: PaoInt", + "range": { + "start": 39745, + "end": 39777 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_Int_Int", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int", + "range": { + "start": 39790, + "end": 39859 + }, + "inputs": [ + "closure", + "arg0" + ] + } + ], + "edges": [ + { + "from": "closure", + "to": "cap0", + "kind": "operand", + "index": 0 + }, + { + "from": "closure", + "to": "cap1", + "kind": "operand", + "index": 1 + }, + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cap0", + "cap1", + "arg0", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@40068:40173", + "bound_var": "rhs", + "source_text": "ctx.insert_paon_int_self_tuple_int_i_int_tuple_int_getitem_self_int_add_i_n(pat.cap0, pat.cap1, pat.arg0)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "cap0", + "cap1" + ], + "referenced_action_vars": [], + "range": { + "start": 40068, + "end": 40173 + } + }, + { + "id": "effect_1", + "effect_id": "effect@40187:40210", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 40187, + "end": 40210 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0011_UF__n_Int_self_TupleInt_i_Int__TupleInt___getitem___self__Int___add___i_n__", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__n_Int_self_TupleInt_i_Int__TupleInt___getitem___self__Int___add___i_n__\")(cap0, cap1), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__n_Int_self_TupleInt_i_Int__TupleInt___getitem___self__Int___add___i_n__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaonIntSelfTupleIntIIntTupleIntGetitemSelfIntAddIN\")(cap0, cap1, arg0)", + "colored_source": "upright(\"PaonIntSelfTupleIntIIntTupleIntGetitemSelfIntAddIN\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__n_Int_self_TupleInt_i_Int__TupleInt___getitem___self__Int___add___i_n__\")(cap0, cap1), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__n_Int_self_TupleInt_i_Int__TupleInt___getitem___self__Int___add___i_n__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaonIntSelfTupleIntIIntTupleIntGetitemSelfIntAddIN\")(cap0, cap1, arg0)", + "colored_source": "upright(\"PaonIntSelfTupleIntIIntTupleIntGetitemSelfIntAddIN\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__n_Int_self_TupleInt_i_Int__TupleInt___getitem___self__Int___add___i_n__\")(cap0, cap1), arg0), upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__n_Int_self_TupleInt_i_Int__TupleInt___getitem___self__Int___add___i_n__\")(cap0, cap1), arg0) arrow.r.double upright(\"PaonIntSelfTupleIntIIntTupleIntGetitemSelfIntAddIN\")(cap0, cap1, arg0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__n_Int_self_TupleInt_i_Int__TupleInt___getitem___self__Int___add___i_n__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]), upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__n_Int_self_TupleInt_i_Int__TupleInt___getitem___self__Int___add___i_n__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]) arrow.r.double upright(\"PaonIntSelfTupleIntIIntTupleIntGetitemSelfIntAddIN\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__801_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0012_UF_other_TupleInt_self_TupleInt_i_Int_Int_if_Int_lt_i_TupleInt_length_self_TupleInt_getitem_self_i_TupleInt_getitem_other_Int_sub_i_TupleInt_length_self__27380fdc332aa1d6", + "display_name": "pao_beta_0012_UF__other_TupleInt_self_TupleInt_i_Int__Int_if___Int___lt___i__TupleInt_length_self____TupleInt___getitem___self_i___TupleInt___getitem___other__Int___sub___i__TupleInt_length_self____", + "rule_name": "pao_beta_0012_UF__other_TupleInt_self_TupleInt_i_Int__Int_if___Int___lt___i__TupleInt_length_self____TupleInt___getitem___self_i___TupleInt___getitem___other__Int___sub___i__TupleInt_length_self____", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 40234, + "line": 801, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 40234, + "end": 41439 + }, + "pattern_range": { + "start": 40504, + "end": 41140 + }, + "action_range": { + "start": 41150, + "end": 41432 + } + }, + "nodes": [ + { + "id": "cap0", + "kind": "query_leaf", + "dsl_type": "PaoTupleInt", + "label": "cap0: PaoTupleInt", + "range": { + "start": 40521, + "end": 40558 + }, + "inputs": [] + }, + { + "id": "cap1", + "kind": "query_leaf", + "dsl_type": "PaoTupleInt", + "label": "cap1: PaoTupleInt", + "range": { + "start": 40571, + "end": 40608 + }, + "inputs": [] + }, + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__other_TupleInt_self_TupleInt_i_Int__Int_if___Int___lt___i__TupleInt_length_self____TupleInt___getitem___self_i___TupleInt___getitem___other__Int___sub___i__TupleInt_length_self____", + "label": "closure: PaoUF__other_TupleInt_self_TupleInt_i_Int__Int_if___Int___lt___i__TupleInt_length_self____TupleInt___getitem___self_i___TupleInt___getitem___other__Int___sub___i__TupleInt_length_self____", + "range": { + "start": 40621, + "end": 40844 + }, + "inputs": [ + "cap0", + "cap1" + ] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg0: PaoInt", + "range": { + "start": 40857, + "end": 40889 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_Int_Int", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int", + "range": { + "start": 40902, + "end": 40971 + }, + "inputs": [ + "closure", + "arg0" + ] + } + ], + "edges": [ + { + "from": "closure", + "to": "cap0", + "kind": "operand", + "index": 0 + }, + { + "from": "closure", + "to": "cap1", + "kind": "operand", + "index": 1 + }, + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cap0", + "cap1", + "arg0", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@41185:41384", + "bound_var": "rhs", + "source_text": "ctx.insert_paoother_tuple_int_self_tuple_int_i_int_int_if_int_lt_i_tuple_int_length_self_tuple_int_getitem_self_i_tuple_int_getitem_other_int_sub_i_tuple_int_length_self(pat.cap0, pat.cap1, pat.arg0)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "cap0", + "cap1" + ], + "referenced_action_vars": [], + "range": { + "start": 41185, + "end": 41384 + } + }, + { + "id": "effect_1", + "effect_id": "effect@41398:41421", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 41398, + "end": 41421 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0012_UF__other_TupleInt_self_TupleInt_i_Int__Int_if___Int___lt___i__TupleInt_length_self____TupleInt___getitem___self_i___TupleInt___getitem___other__Int___sub___i__TupleInt_length_self____", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__other_TupleInt_self_TupleInt_i_Int__Int_if___Int___lt___i__TupleInt_length_self____TupleInt___getitem___self_i___TupleInt___getitem___other__Int___sub___i__TupleInt_length_self____\")(cap0, cap1), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__other_TupleInt_self_TupleInt_i_Int__Int_if___Int___lt___i__TupleInt_length_self____TupleInt___getitem___self_i___TupleInt___getitem___other__Int___sub___i__TupleInt_length_self____\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaootherTupleIntSelfTupleIntIIntIntIfIntLtITupleIntLengthSelfTupleIntGetitemSelfITupleIntGetitemOtherIntSubITupleIntLengthSelf\")(cap0, cap1, arg0)", + "colored_source": "upright(\"PaootherTupleIntSelfTupleIntIIntIntIfIntLtITupleIntLengthSelfTupleIntGetitemSelfITupleIntGetitemOtherIntSubITupleIntLengthSelf\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__other_TupleInt_self_TupleInt_i_Int__Int_if___Int___lt___i__TupleInt_length_self____TupleInt___getitem___self_i___TupleInt___getitem___other__Int___sub___i__TupleInt_length_self____\")(cap0, cap1), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__other_TupleInt_self_TupleInt_i_Int__Int_if___Int___lt___i__TupleInt_length_self____TupleInt___getitem___self_i___TupleInt___getitem___other__Int___sub___i__TupleInt_length_self____\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaootherTupleIntSelfTupleIntIIntIntIfIntLtITupleIntLengthSelfTupleIntGetitemSelfITupleIntGetitemOtherIntSubITupleIntLengthSelf\")(cap0, cap1, arg0)", + "colored_source": "upright(\"PaootherTupleIntSelfTupleIntIIntIntIfIntLtITupleIntLengthSelfTupleIntGetitemSelfITupleIntGetitemOtherIntSubITupleIntLengthSelf\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__other_TupleInt_self_TupleInt_i_Int__Int_if___Int___lt___i__TupleInt_length_self____TupleInt___getitem___self_i___TupleInt___getitem___other__Int___sub___i__TupleInt_length_self____\")(cap0, cap1), arg0), upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__other_TupleInt_self_TupleInt_i_Int__Int_if___Int___lt___i__TupleInt_length_self____TupleInt___getitem___self_i___TupleInt___getitem___other__Int___sub___i__TupleInt_length_self____\")(cap0, cap1), arg0) arrow.r.double upright(\"PaootherTupleIntSelfTupleIntIIntIntIfIntLtITupleIntLengthSelfTupleIntGetitemSelfITupleIntGetitemOtherIntSubITupleIntLengthSelf\")(cap0, cap1, arg0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__other_TupleInt_self_TupleInt_i_Int__Int_if___Int___lt___i__TupleInt_length_self____TupleInt___getitem___self_i___TupleInt___getitem___other__Int___sub___i__TupleInt_length_self____\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]), upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__other_TupleInt_self_TupleInt_i_Int__Int_if___Int___lt___i__TupleInt_length_self____TupleInt___getitem___self_i___TupleInt___getitem___other__Int___sub___i__TupleInt_length_self____\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]) arrow.r.double upright(\"PaootherTupleIntSelfTupleIntIIntIntIfIntLtITupleIntLengthSelfTupleIntGetitemSelfITupleIntGetitemOtherIntSubITupleIntLengthSelf\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__818_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0013_UF_self_TupleInt_i_Int_TupleInt_getitem_self_i__0ea1c165ccb2a564", + "display_name": "pao_beta_0013_UF__self_TupleInt_i_Int__TupleInt___getitem___self_i_", + "rule_name": "pao_beta_0013_UF__self_TupleInt_i_Int__TupleInt___getitem___self_i_", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 41445, + "line": 818, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 41445, + "end": 42192 + }, + "pattern_range": { + "start": 41584, + "end": 42013 + }, + "action_range": { + "start": 42023, + "end": 42185 + } + }, + "nodes": [ + { + "id": "cap0", + "kind": "query_leaf", + "dsl_type": "PaoTupleInt", + "label": "cap0: PaoTupleInt", + "range": { + "start": 41601, + "end": 41638 + }, + "inputs": [] + }, + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__self_TupleInt_i_Int__TupleInt___getitem___self_i_", + "label": "closure: PaoUF__self_TupleInt_i_Int__TupleInt___getitem___self_i_", + "range": { + "start": 41651, + "end": 41736 + }, + "inputs": [ + "cap0" + ] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg0: PaoInt", + "range": { + "start": 41749, + "end": 41781 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_Int_Int", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int", + "range": { + "start": 41794, + "end": 41863 + }, + "inputs": [ + "closure", + "arg0" + ] + } + ], + "edges": [ + { + "from": "closure", + "to": "cap0", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cap0", + "arg0", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@42058:42137", + "bound_var": "rhs", + "source_text": "ctx.insert_paoself_tuple_int_i_int_tuple_int_getitem_self_i(pat.cap0, pat.arg0)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "cap0" + ], + "referenced_action_vars": [], + "range": { + "start": 42058, + "end": 42137 + } + }, + { + "id": "effect_1", + "effect_id": "effect@42151:42174", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 42151, + "end": 42174 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0013_UF__self_TupleInt_i_Int__TupleInt___getitem___self_i_", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__self_TupleInt_i_Int__TupleInt___getitem___self_i_\")(cap0), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__self_TupleInt_i_Int__TupleInt___getitem___self_i_\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoselfTupleIntIIntTupleIntGetitemSelfI\")(cap0, arg0)", + "colored_source": "upright(\"PaoselfTupleIntIIntTupleIntGetitemSelfI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__self_TupleInt_i_Int__TupleInt___getitem___self_i_\")(cap0), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__self_TupleInt_i_Int__TupleInt___getitem___self_i_\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoselfTupleIntIIntTupleIntGetitemSelfI\")(cap0, arg0)", + "colored_source": "upright(\"PaoselfTupleIntIIntTupleIntGetitemSelfI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__self_TupleInt_i_Int__TupleInt___getitem___self_i_\")(cap0), arg0), upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__self_TupleInt_i_Int__TupleInt___getitem___self_i_\")(cap0), arg0) arrow.r.double upright(\"PaoselfTupleIntIIntTupleIntGetitemSelfI\")(cap0, arg0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__self_TupleInt_i_Int__TupleInt___getitem___self_i_\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]), upright(\"PaoUnstableApp__UnstableFn_Int_Int\")(upright(\"PaoUF__self_TupleInt_i_Int__TupleInt___getitem___self_i_\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]) arrow.r.double upright(\"PaoselfTupleIntIIntTupleIntGetitemSelfI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__834_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0014_UF_Int_mul__2b5a800c2b1473a4", + "display_name": "pao_beta_0014_UF__Int___mul__", + "rule_name": "pao_beta_0014_UF__Int___mul__", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 42198, + "line": 834, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 42198, + "end": 42832 + }, + "pattern_range": { + "start": 42299, + "end": 42690 + }, + "action_range": { + "start": 42700, + "end": 42825 + } + }, + "nodes": [ + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__Int___mul__", + "label": "closure: PaoUF__Int___mul__", + "range": { + "start": 42316, + "end": 42358 + }, + "inputs": [] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg0: PaoInt", + "range": { + "start": 42371, + "end": 42403 + }, + "inputs": [] + }, + { + "id": "arg1", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg1: PaoInt", + "range": { + "start": 42416, + "end": 42448 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_Int_Int_Int", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int_Int", + "range": { + "start": 42461, + "end": 42541 + }, + "inputs": [ + "closure", + "arg0", + "arg1" + ] + } + ], + "edges": [ + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + }, + { + "from": "app", + "to": "arg1", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "arg0", + "arg1", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@42735:42777", + "bound_var": "rhs", + "source_text": "ctx.insert_pao_int_mul(pat.arg0, pat.arg1)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "arg1" + ], + "referenced_action_vars": [], + "range": { + "start": 42735, + "end": 42777 + } + }, + { + "id": "effect_1", + "effect_id": "effect@42791:42814", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 42791, + "end": 42814 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0014_UF__Int___mul__", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int_Int\")(upright(\"closure\"), arg0, arg1)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int_Int\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoIntMul\")(arg0, arg1)", + "colored_source": "upright(\"PaoIntMul\")(#text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int_Int\")(upright(\"closure\"), arg0, arg1)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int_Int\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoIntMul\")(arg0, arg1)", + "colored_source": "upright(\"PaoIntMul\")(#text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_Int_Int_Int\")(upright(\"closure\"), arg0, arg1), upright(\"PaoUnstableApp__UnstableFn_Int_Int_Int\")(upright(\"closure\"), arg0, arg1) arrow.r.double upright(\"PaoIntMul\")(arg0, arg1)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_Int_Int_Int\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $]), upright(\"PaoUnstableApp__UnstableFn_Int_Int_Int\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $]) arrow.r.double upright(\"PaoIntMul\")(#text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__850_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0015_UF_acc_Int_i_Int_Int_mul_acc_i__1aaa7c3c093aaa51", + "display_name": "pao_beta_0015_UF__acc_Int_i_Int__Int___mul___acc_i_", + "rule_name": "pao_beta_0015_UF__acc_Int_i_Int__Int___mul___acc_i_", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 42838, + "line": 850, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 42838, + "end": 43535 + }, + "pattern_range": { + "start": 42961, + "end": 43374 + }, + "action_range": { + "start": 43384, + "end": 43528 + } + }, + "nodes": [ + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__acc_Int_i_Int__Int___mul___acc_i_", + "label": "closure: PaoUF__acc_Int_i_Int__Int___mul___acc_i_", + "range": { + "start": 42978, + "end": 43042 + }, + "inputs": [] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg0: PaoInt", + "range": { + "start": 43055, + "end": 43087 + }, + "inputs": [] + }, + { + "id": "arg1", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg1: PaoInt", + "range": { + "start": 43100, + "end": 43132 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_Int_Int_Int", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int_Int", + "range": { + "start": 43145, + "end": 43225 + }, + "inputs": [ + "closure", + "arg0", + "arg1" + ] + } + ], + "edges": [ + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + }, + { + "from": "app", + "to": "arg1", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "arg0", + "arg1", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@43419:43480", + "bound_var": "rhs", + "source_text": "ctx.insert_paoacc_int_i_int_int_mul_acc_i(pat.arg0, pat.arg1)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "arg1" + ], + "referenced_action_vars": [], + "range": { + "start": 43419, + "end": 43480 + } + }, + { + "id": "effect_1", + "effect_id": "effect@43494:43517", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 43494, + "end": 43517 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0015_UF__acc_Int_i_Int__Int___mul___acc_i_", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int_Int\")(upright(\"closure\"), arg0, arg1)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int_Int\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoaccIntIIntIntMulAccI\")(arg0, arg1)", + "colored_source": "upright(\"PaoaccIntIIntIntMulAccI\")(#text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Int_Int_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int_Int\")(upright(\"closure\"), arg0, arg1)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Int_Int_Int\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoaccIntIIntIntMulAccI\")(arg0, arg1)", + "colored_source": "upright(\"PaoaccIntIIntIntMulAccI\")(#text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_Int_Int_Int\")(upright(\"closure\"), arg0, arg1), upright(\"PaoUnstableApp__UnstableFn_Int_Int_Int\")(upright(\"closure\"), arg0, arg1) arrow.r.double upright(\"PaoaccIntIIntIntMulAccI\")(arg0, arg1)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_Int_Int_Int\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $]), upright(\"PaoUnstableApp__UnstableFn_Int_Int_Int\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $]) arrow.r.double upright(\"PaoaccIntIIntIntMulAccI\")(#text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__866_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0016_UF_x_TupleInt_TupleInt_length_x__335af7cfde234957", + "display_name": "pao_beta_0016_UF__x_TupleInt__TupleInt_length_x_", + "rule_name": "pao_beta_0016_UF__x_TupleInt__TupleInt_length_x_", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 43541, + "line": 866, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 43541, + "end": 44171 + }, + "pattern_range": { + "start": 43661, + "end": 44017 + }, + "action_range": { + "start": 44027, + "end": 44164 + } + }, + "nodes": [ + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__x_TupleInt__TupleInt_length_x_", + "label": "closure: PaoUF__x_TupleInt__TupleInt_length_x_", + "range": { + "start": 43678, + "end": 43739 + }, + "inputs": [] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoTupleInt", + "label": "arg0: PaoTupleInt", + "range": { + "start": 43752, + "end": 43789 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_Int_TupleInt", + "label": "app: PaoUnstableApp__UnstableFn_Int_TupleInt", + "range": { + "start": 43802, + "end": 43876 + }, + "inputs": [ + "closure", + "arg0" + ] + } + ], + "edges": [ + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "arg0", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@44062:44116", + "bound_var": "rhs", + "source_text": "ctx.insert_paox_tuple_int_tuple_int_length_x(pat.arg0)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0" + ], + "referenced_action_vars": [], + "range": { + "start": 44062, + "end": 44116 + } + }, + { + "id": "effect_1", + "effect_id": "effect@44130:44153", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 44130, + "end": 44153 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0016_UF__x_TupleInt__TupleInt_length_x_", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Int_TupleInt", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Int_TupleInt\")(upright(\"closure\"), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Int_TupleInt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoxTupleIntTupleIntLengthX\")(arg0)", + "colored_source": "upright(\"PaoxTupleIntTupleIntLengthX\")(#text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Int_TupleInt", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Int_TupleInt\")(upright(\"closure\"), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Int_TupleInt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoxTupleIntTupleIntLengthX\")(arg0)", + "colored_source": "upright(\"PaoxTupleIntTupleIntLengthX\")(#text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_Int_TupleInt\")(upright(\"closure\"), arg0), upright(\"PaoUnstableApp__UnstableFn_Int_TupleInt\")(upright(\"closure\"), arg0) arrow.r.double upright(\"PaoxTupleIntTupleIntLengthX\")(arg0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_Int_TupleInt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]), upright(\"PaoUnstableApp__UnstableFn_Int_TupleInt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]) arrow.r.double upright(\"PaoxTupleIntTupleIntLengthX\")(#text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__881_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0017_UF_idx_fn_UnstableFn_MultiAxisIndexKeyItem_Int_i_Int_unstable_app_idx_fn_Int_add_i_expr_3819518261003242831__bac92fd0719ae587", + "display_name": "pao_beta_0017_UF__idx_fn_UnstableFn_MultiAxisIndexKeyItem_Int_i_Int__unstable_app_idx_fn__Int___add___i____expr__3819518261003242831__", + "rule_name": "pao_beta_0017_UF__idx_fn_UnstableFn_MultiAxisIndexKeyItem_Int_i_Int__unstable_app_idx_fn__Int___add___i____expr__3819518261003242831__", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 44177, + "line": 881, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 44177, + "end": 45214 + }, + "pattern_range": { + "start": 44383, + "end": 44971 + }, + "action_range": { + "start": 44981, + "end": 45207 + } + }, + "nodes": [ + { + "id": "cap0", + "kind": "query_leaf", + "dsl_type": "PaoUnstableFn_MultiAxisIndexKeyItem_Int", + "label": "cap0: PaoUnstableFn_MultiAxisIndexKeyItem_Int", + "range": { + "start": 44400, + "end": 44465 + }, + "inputs": [] + }, + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__idx_fn_UnstableFn_MultiAxisIndexKeyItem_Int_i_Int__unstable_app_idx_fn__Int___add___i____expr__3819518261003242831__", + "label": "closure: PaoUF__idx_fn_UnstableFn_MultiAxisIndexKeyItem_Int_i_Int__unstable_app_idx_fn__Int___add___i____expr__3819518261003242831__", + "range": { + "start": 44478, + "end": 44630 + }, + "inputs": [ + "cap0" + ] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg0: PaoInt", + "range": { + "start": 44643, + "end": 44675 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_MultiAxisIndexKeyItem_Int", + "label": "app: PaoUnstableApp__UnstableFn_MultiAxisIndexKeyItem_Int", + "range": { + "start": 44688, + "end": 44775 + }, + "inputs": [ + "closure", + "arg0" + ] + } + ], + "edges": [ + { + "from": "closure", + "to": "cap0", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cap0", + "arg0", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@45016:45159", + "bound_var": "rhs", + "source_text": "ctx.insert_paoidx_fn_unstable_fn_multi_axis_index_key_item_int_i_int_unstable_app_idx_fn_int_add_i_expr_3819518261003242831(pat.cap0, pat.arg0)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "cap0" + ], + "referenced_action_vars": [], + "range": { + "start": 45016, + "end": 45159 + } + }, + { + "id": "effect_1", + "effect_id": "effect@45173:45196", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 45173, + "end": 45196 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0017_UF__idx_fn_UnstableFn_MultiAxisIndexKeyItem_Int_i_Int__unstable_app_idx_fn__Int___add___i____expr__3819518261003242831__", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_MultiAxisIndexKeyItem_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_MultiAxisIndexKeyItem_Int\")(upright(\"PaoUF__idx_fn_UnstableFn_MultiAxisIndexKeyItem_Int_i_Int__unstable_app_idx_fn__Int___add___i____expr__3819518261003242831__\")(cap0), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_MultiAxisIndexKeyItem_Int\")(upright(\"PaoUF__idx_fn_UnstableFn_MultiAxisIndexKeyItem_Int_i_Int__unstable_app_idx_fn__Int___add___i____expr__3819518261003242831__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoidxFnUnstableFnMultiAxisIndexKeyItemIntIIntUnstableAppIdxFnIntAddIExpr3819518261003242831\")(cap0, arg0)", + "colored_source": "upright(\"PaoidxFnUnstableFnMultiAxisIndexKeyItemIntIIntUnstableAppIdxFnIntAddIExpr3819518261003242831\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_MultiAxisIndexKeyItem_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_MultiAxisIndexKeyItem_Int\")(upright(\"PaoUF__idx_fn_UnstableFn_MultiAxisIndexKeyItem_Int_i_Int__unstable_app_idx_fn__Int___add___i____expr__3819518261003242831__\")(cap0), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_MultiAxisIndexKeyItem_Int\")(upright(\"PaoUF__idx_fn_UnstableFn_MultiAxisIndexKeyItem_Int_i_Int__unstable_app_idx_fn__Int___add___i____expr__3819518261003242831__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoidxFnUnstableFnMultiAxisIndexKeyItemIntIIntUnstableAppIdxFnIntAddIExpr3819518261003242831\")(cap0, arg0)", + "colored_source": "upright(\"PaoidxFnUnstableFnMultiAxisIndexKeyItemIntIIntUnstableAppIdxFnIntAddIExpr3819518261003242831\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_MultiAxisIndexKeyItem_Int\")(upright(\"PaoUF__idx_fn_UnstableFn_MultiAxisIndexKeyItem_Int_i_Int__unstable_app_idx_fn__Int___add___i____expr__3819518261003242831__\")(cap0), arg0), upright(\"PaoUnstableApp__UnstableFn_MultiAxisIndexKeyItem_Int\")(upright(\"PaoUF__idx_fn_UnstableFn_MultiAxisIndexKeyItem_Int_i_Int__unstable_app_idx_fn__Int___add___i____expr__3819518261003242831__\")(cap0), arg0) arrow.r.double upright(\"PaoidxFnUnstableFnMultiAxisIndexKeyItemIntIIntUnstableAppIdxFnIntAddIExpr3819518261003242831\")(cap0, arg0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_MultiAxisIndexKeyItem_Int\")(upright(\"PaoUF__idx_fn_UnstableFn_MultiAxisIndexKeyItem_Int_i_Int__unstable_app_idx_fn__Int___add___i____expr__3819518261003242831__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]), upright(\"PaoUnstableApp__UnstableFn_MultiAxisIndexKeyItem_Int\")(upright(\"PaoUF__idx_fn_UnstableFn_MultiAxisIndexKeyItem_Int_i_Int__unstable_app_idx_fn__Int___add___i____expr__3819518261003242831__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]) arrow.r.double upright(\"PaoidxFnUnstableFnMultiAxisIndexKeyItemIntIIntUnstableAppIdxFnIntAddIExpr3819518261003242831\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__897_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0018_UF_TupleNDArray_getitem__c8ffb29ca5063bdc", + "display_name": "pao_beta_0018_UF__TupleNDArray___getitem__", + "rule_name": "pao_beta_0018_UF__TupleNDArray___getitem__", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 45220, + "line": 897, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 45220, + "end": 45911 + }, + "pattern_range": { + "start": 45334, + "end": 45754 + }, + "action_range": { + "start": 45764, + "end": 45904 + } + }, + "nodes": [ + { + "id": "cap0", + "kind": "query_leaf", + "dsl_type": "PaoTupleNDArray", + "label": "cap0: PaoTupleNDArray", + "range": { + "start": 45351, + "end": 45392 + }, + "inputs": [] + }, + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__TupleNDArray___getitem__", + "label": "closure: PaoUF__TupleNDArray___getitem__", + "range": { + "start": 45405, + "end": 45465 + }, + "inputs": [ + "cap0" + ] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg0: PaoInt", + "range": { + "start": 45478, + "end": 45510 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_NDArray_Int", + "label": "app: PaoUnstableApp__UnstableFn_NDArray_Int", + "range": { + "start": 45523, + "end": 45596 + }, + "inputs": [ + "closure", + "arg0" + ] + } + ], + "edges": [ + { + "from": "closure", + "to": "cap0", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cap0", + "arg0", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@45799:45856", + "bound_var": "rhs", + "source_text": "ctx.insert_pao_tuple_nd_array_getitem(pat.cap0, pat.arg0)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "cap0" + ], + "referenced_action_vars": [], + "range": { + "start": 45799, + "end": 45856 + } + }, + { + "id": "effect_1", + "effect_id": "effect@45870:45893", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 45870, + "end": 45893 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0018_UF__TupleNDArray___getitem__", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_NDArray_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_NDArray_Int\")(upright(\"PaoUF__TupleNDArray___getitem__\")(cap0), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_NDArray_Int\")(upright(\"PaoUF__TupleNDArray___getitem__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoTupleNdArrayGetitem\")(cap0, arg0)", + "colored_source": "upright(\"PaoTupleNdArrayGetitem\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_NDArray_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_NDArray_Int\")(upright(\"PaoUF__TupleNDArray___getitem__\")(cap0), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_NDArray_Int\")(upright(\"PaoUF__TupleNDArray___getitem__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoTupleNdArrayGetitem\")(cap0, arg0)", + "colored_source": "upright(\"PaoTupleNdArrayGetitem\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_NDArray_Int\")(upright(\"PaoUF__TupleNDArray___getitem__\")(cap0), arg0), upright(\"PaoUnstableApp__UnstableFn_NDArray_Int\")(upright(\"PaoUF__TupleNDArray___getitem__\")(cap0), arg0) arrow.r.double upright(\"PaoTupleNdArrayGetitem\")(cap0, arg0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_NDArray_Int\")(upright(\"PaoUF__TupleNDArray___getitem__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]), upright(\"PaoUnstableApp__UnstableFn_NDArray_Int\")(upright(\"PaoUF__TupleNDArray___getitem__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]) arrow.r.double upright(\"PaoTupleNdArrayGetitem\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__913_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0019_UF_other_TupleNDArray_self_TupleNDArray_i_Int_NDArray_if_Int_lt_i_TupleNDArray_length_self_TupleNDArray_getitem_self_i_TupleNDArray_getitem_other_Int_sub_i_TupleNDArray_length_self__cd5ca3fa4506c57f", + "display_name": "pao_beta_0019_UF__other_TupleNDArray_self_TupleNDArray_i_Int__NDArray_if___Int___lt___i__TupleNDArray_length_self____TupleNDArray___getitem___self_i___TupleNDArray___getitem___other__Int___sub___i__TupleNDArray_length_self____", + "rule_name": "pao_beta_0019_UF__other_TupleNDArray_self_TupleNDArray_i_Int__NDArray_if___Int___lt___i__TupleNDArray_length_self____TupleNDArray___getitem___self_i___TupleNDArray___getitem___other__Int___sub___i__TupleNDArray_length_self____", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 45917, + "line": 913, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 45917, + "end": 47237 + }, + "pattern_range": { + "start": 46215, + "end": 46903 + }, + "action_range": { + "start": 46913, + "end": 47230 + } + }, + "nodes": [ + { + "id": "cap0", + "kind": "query_leaf", + "dsl_type": "PaoTupleNDArray", + "label": "cap0: PaoTupleNDArray", + "range": { + "start": 46232, + "end": 46273 + }, + "inputs": [] + }, + { + "id": "cap1", + "kind": "query_leaf", + "dsl_type": "PaoTupleNDArray", + "label": "cap1: PaoTupleNDArray", + "range": { + "start": 46286, + "end": 46327 + }, + "inputs": [] + }, + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__other_TupleNDArray_self_TupleNDArray_i_Int__NDArray_if___Int___lt___i__TupleNDArray_length_self____TupleNDArray___getitem___self_i___TupleNDArray___getitem___other__Int___sub___i__TupleNDArray_length_self____", + "label": "closure: PaoUF__other_TupleNDArray_self_TupleNDArray_i_Int__NDArray_if___Int___lt___i__TupleNDArray_length_self____TupleNDArray___getitem___self_i___TupleNDArray___getitem___other__Int___sub___i__TupleNDArray_length_self____", + "range": { + "start": 46340, + "end": 46591 + }, + "inputs": [ + "cap0", + "cap1" + ] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg0: PaoInt", + "range": { + "start": 46604, + "end": 46636 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_NDArray_Int", + "label": "app: PaoUnstableApp__UnstableFn_NDArray_Int", + "range": { + "start": 46649, + "end": 46722 + }, + "inputs": [ + "closure", + "arg0" + ] + } + ], + "edges": [ + { + "from": "closure", + "to": "cap0", + "kind": "operand", + "index": 0 + }, + { + "from": "closure", + "to": "cap1", + "kind": "operand", + "index": 1 + }, + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cap0", + "cap1", + "arg0", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@46948:47182", + "bound_var": "rhs", + "source_text": "ctx.insert_paoother_tuple_nd_array_self_tuple_nd_array_i_int_nd_array_if_int_lt_i_tuple_nd_array_length_self_tuple_nd_array_getitem_self_i_tuple_nd_array_getitem_other_int_sub_i_tuple_nd_array_length_self(pat.cap0, pat.cap1, pat.arg0)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "cap0", + "cap1" + ], + "referenced_action_vars": [], + "range": { + "start": 46948, + "end": 47182 + } + }, + { + "id": "effect_1", + "effect_id": "effect@47196:47219", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 47196, + "end": 47219 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0019_UF__other_TupleNDArray_self_TupleNDArray_i_Int__NDArray_if___Int___lt___i__TupleNDArray_length_self____TupleNDArray___getitem___self_i___TupleNDArray___getitem___other__Int___sub___i__TupleNDArray_length_self____", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_NDArray_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_NDArray_Int\")(upright(\"PaoUF__other_TupleNDArray_self_TupleNDArray_i_Int__NDArray_if___Int___lt___i__TupleNDArray_length_self____TupleNDArray___getitem___self_i___TupleNDArray___getitem___other__Int___sub___i__TupleNDArray_length_self____\")(cap0, cap1), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_NDArray_Int\")(upright(\"PaoUF__other_TupleNDArray_self_TupleNDArray_i_Int__NDArray_if___Int___lt___i__TupleNDArray_length_self____TupleNDArray___getitem___self_i___TupleNDArray___getitem___other__Int___sub___i__TupleNDArray_length_self____\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaootherTupleNdArraySelfTupleNdArrayIIntNdArrayIfIntLtITupleNdArrayLengthSelfTupleNdArrayGetitemSelfITupleNdArrayGetitemOtherIntSubITupleNdArrayLengthSelf\")(cap0, cap1, arg0)", + "colored_source": "upright(\"PaootherTupleNdArraySelfTupleNdArrayIIntNdArrayIfIntLtITupleNdArrayLengthSelfTupleNdArrayGetitemSelfITupleNdArrayGetitemOtherIntSubITupleNdArrayLengthSelf\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_NDArray_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_NDArray_Int\")(upright(\"PaoUF__other_TupleNDArray_self_TupleNDArray_i_Int__NDArray_if___Int___lt___i__TupleNDArray_length_self____TupleNDArray___getitem___self_i___TupleNDArray___getitem___other__Int___sub___i__TupleNDArray_length_self____\")(cap0, cap1), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_NDArray_Int\")(upright(\"PaoUF__other_TupleNDArray_self_TupleNDArray_i_Int__NDArray_if___Int___lt___i__TupleNDArray_length_self____TupleNDArray___getitem___self_i___TupleNDArray___getitem___other__Int___sub___i__TupleNDArray_length_self____\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaootherTupleNdArraySelfTupleNdArrayIIntNdArrayIfIntLtITupleNdArrayLengthSelfTupleNdArrayGetitemSelfITupleNdArrayGetitemOtherIntSubITupleNdArrayLengthSelf\")(cap0, cap1, arg0)", + "colored_source": "upright(\"PaootherTupleNdArraySelfTupleNdArrayIIntNdArrayIfIntLtITupleNdArrayLengthSelfTupleNdArrayGetitemSelfITupleNdArrayGetitemOtherIntSubITupleNdArrayLengthSelf\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_NDArray_Int\")(upright(\"PaoUF__other_TupleNDArray_self_TupleNDArray_i_Int__NDArray_if___Int___lt___i__TupleNDArray_length_self____TupleNDArray___getitem___self_i___TupleNDArray___getitem___other__Int___sub___i__TupleNDArray_length_self____\")(cap0, cap1), arg0), upright(\"PaoUnstableApp__UnstableFn_NDArray_Int\")(upright(\"PaoUF__other_TupleNDArray_self_TupleNDArray_i_Int__NDArray_if___Int___lt___i__TupleNDArray_length_self____TupleNDArray___getitem___self_i___TupleNDArray___getitem___other__Int___sub___i__TupleNDArray_length_self____\")(cap0, cap1), arg0) arrow.r.double upright(\"PaootherTupleNdArraySelfTupleNdArrayIIntNdArrayIfIntLtITupleNdArrayLengthSelfTupleNdArrayGetitemSelfITupleNdArrayGetitemOtherIntSubITupleNdArrayLengthSelf\")(cap0, cap1, arg0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_NDArray_Int\")(upright(\"PaoUF__other_TupleNDArray_self_TupleNDArray_i_Int__NDArray_if___Int___lt___i__TupleNDArray_length_self____TupleNDArray___getitem___self_i___TupleNDArray___getitem___other__Int___sub___i__TupleNDArray_length_self____\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]), upright(\"PaoUnstableApp__UnstableFn_NDArray_Int\")(upright(\"PaoUF__other_TupleNDArray_self_TupleNDArray_i_Int__NDArray_if___Int___lt___i__TupleNDArray_length_self____TupleNDArray___getitem___self_i___TupleNDArray___getitem___other__Int___sub___i__TupleNDArray_length_self____\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]) arrow.r.double upright(\"PaootherTupleNdArraySelfTupleNdArrayIIntNdArrayIfIntLtITupleNdArrayLengthSelfTupleNdArrayGetitemSelfITupleNdArrayGetitemOtherIntSubITupleNdArrayLengthSelf\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__930_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0020_UF_acc_Program_i_Int_Program_add_Program_add_acc_int_program_i_Program_init_false__afec837b5c055aa8", + "display_name": "pao_beta_0020_UF__acc_Program_i_Int__Program___add____Program___add___acc__int_program_i____Program___init________false__", + "rule_name": "pao_beta_0020_UF__acc_Program_i_Int__Program___add____Program___add___acc__int_program_i____Program___init________false__", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 47243, + "line": 930, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 47243, + "end": 48155 + }, + "pattern_range": { + "start": 47436, + "end": 47943 + }, + "action_range": { + "start": 47953, + "end": 48148 + } + }, + "nodes": [ + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__acc_Program_i_Int__Program___add____Program___add___acc__int_program_i____Program___init________false__", + "label": "closure: PaoUF__acc_Program_i_Int__Program___add____Program___add___acc__int_program_i____Program___init________false__", + "range": { + "start": 47453, + "end": 47587 + }, + "inputs": [] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoProgram", + "label": "arg0: PaoProgram", + "range": { + "start": 47600, + "end": 47636 + }, + "inputs": [] + }, + { + "id": "arg1", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg1: PaoInt", + "range": { + "start": 47649, + "end": 47681 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_Program_Program_Int", + "label": "app: PaoUnstableApp__UnstableFn_Program_Program_Int", + "range": { + "start": 47694, + "end": 47782 + }, + "inputs": [ + "closure", + "arg0", + "arg1" + ] + } + ], + "edges": [ + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + }, + { + "from": "app", + "to": "arg1", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "arg0", + "arg1", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@47988:48100", + "bound_var": "rhs", + "source_text": "ctx.insert_paoacc_program_i_int_program_add_program_add_acc_int_program_i_program_init_false(pat.arg0, pat.arg1)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "arg1" + ], + "referenced_action_vars": [], + "range": { + "start": 47988, + "end": 48100 + } + }, + { + "id": "effect_1", + "effect_id": "effect@48114:48137", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 48114, + "end": 48137 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0020_UF__acc_Program_i_Int__Program___add____Program___add___acc__int_program_i____Program___init________false__", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Program_Program_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Program_Program_Int\")(upright(\"closure\"), arg0, arg1)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Program_Program_Int\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoaccProgramIIntProgramAddProgramAddAccIntProgramIProgramInitFalse\")(arg0, arg1)", + "colored_source": "upright(\"PaoaccProgramIIntProgramAddProgramAddAccIntProgramIProgramInitFalse\")(#text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Program_Program_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Program_Program_Int\")(upright(\"closure\"), arg0, arg1)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Program_Program_Int\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoaccProgramIIntProgramAddProgramAddAccIntProgramIProgramInitFalse\")(arg0, arg1)", + "colored_source": "upright(\"PaoaccProgramIIntProgramAddProgramAddAccIntProgramIProgramInitFalse\")(#text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_Program_Program_Int\")(upright(\"closure\"), arg0, arg1), upright(\"PaoUnstableApp__UnstableFn_Program_Program_Int\")(upright(\"closure\"), arg0, arg1) arrow.r.double upright(\"PaoaccProgramIIntProgramAddProgramAddAccIntProgramIProgramInitFalse\")(arg0, arg1)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_Program_Program_Int\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $]), upright(\"PaoUnstableApp__UnstableFn_Program_Program_Int\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $]) arrow.r.double upright(\"PaoaccProgramIIntProgramAddProgramAddAccIntProgramIProgramInitFalse\")(#text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__946_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0021_UF_acc_Program_i_NDArray_Program_add_Program_add_acc_ndarray_program_i_Program_init_false__4876c93113c2602e", + "display_name": "pao_beta_0021_UF__acc_Program_i_NDArray__Program___add____Program___add___acc__ndarray_program_i____Program___init________false__", + "rule_name": "pao_beta_0021_UF__acc_Program_i_NDArray__Program___add____Program___add___acc__ndarray_program_i____Program___init________false__", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 48161, + "line": 946, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 48161, + "end": 49114 + }, + "pattern_range": { + "start": 48362, + "end": 48893 + }, + "action_range": { + "start": 48903, + "end": 49107 + } + }, + "nodes": [ + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__acc_Program_i_NDArray__Program___add____Program___add___acc__ndarray_program_i____Program___init________false__", + "label": "closure: PaoUF__acc_Program_i_NDArray__Program___add____Program___add___acc__ndarray_program_i____Program___init________false__", + "range": { + "start": 48379, + "end": 48521 + }, + "inputs": [] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoProgram", + "label": "arg0: PaoProgram", + "range": { + "start": 48534, + "end": 48570 + }, + "inputs": [] + }, + { + "id": "arg1", + "kind": "query_leaf", + "dsl_type": "PaoNDArray", + "label": "arg1: PaoNDArray", + "range": { + "start": 48583, + "end": 48619 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_Program_Program_NDArray", + "label": "app: PaoUnstableApp__UnstableFn_Program_Program_NDArray", + "range": { + "start": 48632, + "end": 48724 + }, + "inputs": [ + "closure", + "arg0", + "arg1" + ] + } + ], + "edges": [ + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + }, + { + "from": "app", + "to": "arg1", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "arg0", + "arg1", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@48938:49059", + "bound_var": "rhs", + "source_text": "ctx.insert_paoacc_program_i_nd_array_program_add_program_add_acc_ndarray_program_i_program_init_false(pat.arg0, pat.arg1)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "arg1" + ], + "referenced_action_vars": [], + "range": { + "start": 48938, + "end": 49059 + } + }, + { + "id": "effect_1", + "effect_id": "effect@49073:49096", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 49073, + "end": 49096 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0021_UF__acc_Program_i_NDArray__Program___add____Program___add___acc__ndarray_program_i____Program___init________false__", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Program_Program_NDArray", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Program_Program_NDArray\")(upright(\"closure\"), arg0, arg1)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Program_Program_NDArray\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoaccProgramINdArrayProgramAddProgramAddAccNdarrayProgramIProgramInitFalse\")(arg0, arg1)", + "colored_source": "upright(\"PaoaccProgramINdArrayProgramAddProgramAddAccNdarrayProgramIProgramInitFalse\")(#text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Program_Program_NDArray", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Program_Program_NDArray\")(upright(\"closure\"), arg0, arg1)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Program_Program_NDArray\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoaccProgramINdArrayProgramAddProgramAddAccNdarrayProgramIProgramInitFalse\")(arg0, arg1)", + "colored_source": "upright(\"PaoaccProgramINdArrayProgramAddProgramAddAccNdarrayProgramIProgramInitFalse\")(#text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_Program_Program_NDArray\")(upright(\"closure\"), arg0, arg1), upright(\"PaoUnstableApp__UnstableFn_Program_Program_NDArray\")(upright(\"closure\"), arg0, arg1) arrow.r.double upright(\"PaoaccProgramINdArrayProgramAddProgramAddAccNdarrayProgramIProgramInitFalse\")(arg0, arg1)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_Program_Program_NDArray\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $]), upright(\"PaoUnstableApp__UnstableFn_Program_Program_NDArray\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $]) arrow.r.double upright(\"PaoaccProgramINdArrayProgramAddProgramAddAccNdarrayProgramIProgramInitFalse\")(#text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__962_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0022_UF_acc_Program_i_Value_Program_add_Program_add_acc_value_program_i_Program_init_false__8137d16d411ce5ed", + "display_name": "pao_beta_0022_UF__acc_Program_i_Value__Program___add____Program___add___acc__value_program_i____Program___init________false__", + "rule_name": "pao_beta_0022_UF__acc_Program_i_Value__Program___add____Program___add___acc__value_program_i____Program___init________false__", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 49120, + "line": 962, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 49120, + "end": 50052 + }, + "pattern_range": { + "start": 49317, + "end": 49836 + }, + "action_range": { + "start": 49846, + "end": 50045 + } + }, + "nodes": [ + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__acc_Program_i_Value__Program___add____Program___add___acc__value_program_i____Program___init________false__", + "label": "closure: PaoUF__acc_Program_i_Value__Program___add____Program___add___acc__value_program_i____Program___init________false__", + "range": { + "start": 49334, + "end": 49472 + }, + "inputs": [] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoProgram", + "label": "arg0: PaoProgram", + "range": { + "start": 49485, + "end": 49521 + }, + "inputs": [] + }, + { + "id": "arg1", + "kind": "query_leaf", + "dsl_type": "PaoValue", + "label": "arg1: PaoValue", + "range": { + "start": 49534, + "end": 49568 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_Program_Program_Value", + "label": "app: PaoUnstableApp__UnstableFn_Program_Program_Value", + "range": { + "start": 49581, + "end": 49671 + }, + "inputs": [ + "closure", + "arg0", + "arg1" + ] + } + ], + "edges": [ + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + }, + { + "from": "app", + "to": "arg1", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "arg0", + "arg1", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@49881:49997", + "bound_var": "rhs", + "source_text": "ctx.insert_paoacc_program_i_value_program_add_program_add_acc_value_program_i_program_init_false(pat.arg0, pat.arg1)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "arg1" + ], + "referenced_action_vars": [], + "range": { + "start": 49881, + "end": 49997 + } + }, + { + "id": "effect_1", + "effect_id": "effect@50011:50034", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 50011, + "end": 50034 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0022_UF__acc_Program_i_Value__Program___add____Program___add___acc__value_program_i____Program___init________false__", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Program_Program_Value", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Program_Program_Value\")(upright(\"closure\"), arg0, arg1)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Program_Program_Value\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoaccProgramIValueProgramAddProgramAddAccValueProgramIProgramInitFalse\")(arg0, arg1)", + "colored_source": "upright(\"PaoaccProgramIValueProgramAddProgramAddAccValueProgramIProgramInitFalse\")(#text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Program_Program_Value", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Program_Program_Value\")(upright(\"closure\"), arg0, arg1)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Program_Program_Value\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoaccProgramIValueProgramAddProgramAddAccValueProgramIProgramInitFalse\")(arg0, arg1)", + "colored_source": "upright(\"PaoaccProgramIValueProgramAddProgramAddAccValueProgramIProgramInitFalse\")(#text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_Program_Program_Value\")(upright(\"closure\"), arg0, arg1), upright(\"PaoUnstableApp__UnstableFn_Program_Program_Value\")(upright(\"closure\"), arg0, arg1) arrow.r.double upright(\"PaoaccProgramIValueProgramAddProgramAddAccValueProgramIProgramInitFalse\")(arg0, arg1)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_Program_Program_Value\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $]), upright(\"PaoUnstableApp__UnstableFn_Program_Program_Value\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $]) arrow.r.double upright(\"PaoaccProgramIValueProgramAddProgramAddAccValueProgramIProgramInitFalse\")(#text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__978_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0023_UF_TupleInt_range__9a00834139a7955e", + "display_name": "pao_beta_0023_UF__TupleInt_range", + "rule_name": "pao_beta_0023_UF__TupleInt_range", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 50058, + "line": 978, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 50058, + "end": 50632 + }, + "pattern_range": { + "start": 50162, + "end": 50492 + }, + "action_range": { + "start": 50502, + "end": 50625 + } + }, + "nodes": [ + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__TupleInt_range", + "label": "closure: PaoUF__TupleInt_range", + "range": { + "start": 50179, + "end": 50224 + }, + "inputs": [] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg0: PaoInt", + "range": { + "start": 50237, + "end": 50269 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_TupleInt_Int", + "label": "app: PaoUnstableApp__UnstableFn_TupleInt_Int", + "range": { + "start": 50282, + "end": 50356 + }, + "inputs": [ + "closure", + "arg0" + ] + } + ], + "edges": [ + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "arg0", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@50537:50577", + "bound_var": "rhs", + "source_text": "ctx.insert_pao_tuple_int_range(pat.arg0)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0" + ], + "referenced_action_vars": [], + "range": { + "start": 50537, + "end": 50577 + } + }, + { + "id": "effect_1", + "effect_id": "effect@50591:50614", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 50591, + "end": 50614 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0023_UF__TupleInt_range", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_TupleInt_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"closure\"), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoTupleIntRange\")(arg0)", + "colored_source": "upright(\"PaoTupleIntRange\")(#text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_TupleInt_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"closure\"), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoTupleIntRange\")(arg0)", + "colored_source": "upright(\"PaoTupleIntRange\")(#text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"closure\"), arg0), upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"closure\"), arg0) arrow.r.double upright(\"PaoTupleIntRange\")(arg0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]), upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"closure\") $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]) arrow.r.double upright(\"PaoTupleIntRange\")(#text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__993_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0024_UF_f_UnstableFn_TupleInt_Int_self_TupleInt_i_Int_unstable_app_f_TupleInt_getitem_self_i__743483c948cf2ae2", + "display_name": "pao_beta_0024_UF__f_UnstableFn_TupleInt_Int_self_TupleInt_i_Int__unstable_app_f__TupleInt___getitem___self_i__", + "rule_name": "pao_beta_0024_UF__f_UnstableFn_TupleInt_Int_self_TupleInt_i_Int__unstable_app_f__TupleInt___getitem___self_i__", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 50638, + "line": 993, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 50638, + "end": 51640 + }, + "pattern_range": { + "start": 50820, + "end": 51408 + }, + "action_range": { + "start": 51418, + "end": 51633 + } + }, + "nodes": [ + { + "id": "cap0", + "kind": "query_leaf", + "dsl_type": "PaoUnstableFn_TupleInt_Int", + "label": "cap0: PaoUnstableFn_TupleInt_Int", + "range": { + "start": 50837, + "end": 50889 + }, + "inputs": [] + }, + { + "id": "cap1", + "kind": "query_leaf", + "dsl_type": "PaoTupleInt", + "label": "cap1: PaoTupleInt", + "range": { + "start": 50902, + "end": 50939 + }, + "inputs": [] + }, + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__f_UnstableFn_TupleInt_Int_self_TupleInt_i_Int__unstable_app_f__TupleInt___getitem___self_i__", + "label": "closure: PaoUF__f_UnstableFn_TupleInt_Int_self_TupleInt_i_Int__unstable_app_f__TupleInt___getitem___self_i__", + "range": { + "start": 50952, + "end": 51087 + }, + "inputs": [ + "cap0", + "cap1" + ] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg0: PaoInt", + "range": { + "start": 51100, + "end": 51132 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_TupleInt_Int", + "label": "app: PaoUnstableApp__UnstableFn_TupleInt_Int", + "range": { + "start": 51145, + "end": 51219 + }, + "inputs": [ + "closure", + "arg0" + ] + } + ], + "edges": [ + { + "from": "closure", + "to": "cap0", + "kind": "operand", + "index": 0 + }, + { + "from": "closure", + "to": "cap1", + "kind": "operand", + "index": 1 + }, + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cap0", + "cap1", + "arg0", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@51453:51585", + "bound_var": "rhs", + "source_text": "ctx.insert_paof_unstable_fn_tuple_int_int_self_tuple_int_i_int_unstable_app_f_tuple_int_getitem_self_i(pat.cap0, pat.cap1, pat.arg0)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "cap0", + "cap1" + ], + "referenced_action_vars": [], + "range": { + "start": 51453, + "end": 51585 + } + }, + { + "id": "effect_1", + "effect_id": "effect@51599:51622", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 51599, + "end": 51622 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0024_UF__f_UnstableFn_TupleInt_Int_self_TupleInt_i_Int__unstable_app_f__TupleInt___getitem___self_i__", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_TupleInt_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__f_UnstableFn_TupleInt_Int_self_TupleInt_i_Int__unstable_app_f__TupleInt___getitem___self_i__\")(cap0, cap1), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__f_UnstableFn_TupleInt_Int_self_TupleInt_i_Int__unstable_app_f__TupleInt___getitem___self_i__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaofUnstableFnTupleIntIntSelfTupleIntIIntUnstableAppFTupleIntGetitemSelfI\")(cap0, cap1, arg0)", + "colored_source": "upright(\"PaofUnstableFnTupleIntIntSelfTupleIntIIntUnstableAppFTupleIntGetitemSelfI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_TupleInt_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__f_UnstableFn_TupleInt_Int_self_TupleInt_i_Int__unstable_app_f__TupleInt___getitem___self_i__\")(cap0, cap1), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__f_UnstableFn_TupleInt_Int_self_TupleInt_i_Int__unstable_app_f__TupleInt___getitem___self_i__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaofUnstableFnTupleIntIntSelfTupleIntIIntUnstableAppFTupleIntGetitemSelfI\")(cap0, cap1, arg0)", + "colored_source": "upright(\"PaofUnstableFnTupleIntIntSelfTupleIntIIntUnstableAppFTupleIntGetitemSelfI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__f_UnstableFn_TupleInt_Int_self_TupleInt_i_Int__unstable_app_f__TupleInt___getitem___self_i__\")(cap0, cap1), arg0), upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__f_UnstableFn_TupleInt_Int_self_TupleInt_i_Int__unstable_app_f__TupleInt___getitem___self_i__\")(cap0, cap1), arg0) arrow.r.double upright(\"PaofUnstableFnTupleIntIntSelfTupleIntIIntUnstableAppFTupleIntGetitemSelfI\")(cap0, cap1, arg0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__f_UnstableFn_TupleInt_Int_self_TupleInt_i_Int__unstable_app_f__TupleInt___getitem___self_i__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]), upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__f_UnstableFn_TupleInt_Int_self_TupleInt_i_Int__unstable_app_f__TupleInt___getitem___self_i__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]) arrow.r.double upright(\"PaofUnstableFnTupleIntIntSelfTupleIntIIntUnstableAppFTupleIntGetitemSelfI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__1010_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0025_UF_i_TupleInt_Int_i__324744c9f358d380", + "display_name": "pao_beta_0025_UF__i_TupleInt___Int_i", + "rule_name": "pao_beta_0025_UF__i_TupleInt___Int_i", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 51646, + "line": 1010, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 51646, + "end": 52313 + }, + "pattern_range": { + "start": 51754, + "end": 52162 + }, + "action_range": { + "start": 52172, + "end": 52306 + } + }, + "nodes": [ + { + "id": "cap0", + "kind": "query_leaf", + "dsl_type": "PaoTupleInt", + "label": "cap0: PaoTupleInt", + "range": { + "start": 51771, + "end": 51808 + }, + "inputs": [] + }, + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__i_TupleInt___Int_i", + "label": "closure: PaoUF__i_TupleInt___Int_i", + "range": { + "start": 51821, + "end": 51875 + }, + "inputs": [ + "cap0" + ] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg0: PaoInt", + "range": { + "start": 51888, + "end": 51920 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_TupleInt_Int", + "label": "app: PaoUnstableApp__UnstableFn_TupleInt_Int", + "range": { + "start": 51933, + "end": 52007 + }, + "inputs": [ + "closure", + "arg0" + ] + } + ], + "edges": [ + { + "from": "closure", + "to": "cap0", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cap0", + "arg0", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@52207:52258", + "bound_var": "rhs", + "source_text": "ctx.insert_paoi_tuple_int_int_i(pat.cap0, pat.arg0)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "cap0" + ], + "referenced_action_vars": [], + "range": { + "start": 52207, + "end": 52258 + } + }, + { + "id": "effect_1", + "effect_id": "effect@52272:52295", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 52272, + "end": 52295 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0025_UF__i_TupleInt___Int_i", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_TupleInt_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__i_TupleInt___Int_i\")(cap0), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__i_TupleInt___Int_i\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoiTupleIntIntI\")(cap0, arg0)", + "colored_source": "upright(\"PaoiTupleIntIntI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_TupleInt_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__i_TupleInt___Int_i\")(cap0), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__i_TupleInt___Int_i\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoiTupleIntIntI\")(cap0, arg0)", + "colored_source": "upright(\"PaoiTupleIntIntI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__i_TupleInt___Int_i\")(cap0), arg0), upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__i_TupleInt___Int_i\")(cap0), arg0) arrow.r.double upright(\"PaoiTupleIntIntI\")(cap0, arg0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__i_TupleInt___Int_i\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]), upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__i_TupleInt___Int_i\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]) arrow.r.double upright(\"PaoiTupleIntIntI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__1026_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0026_UF_n_Int_self_TupleTupleInt_i_Int_TupleTupleInt_getitem_self_Int_add_i_n__45fcc6bdbf7a54ea", + "display_name": "pao_beta_0026_UF__n_Int_self_TupleTupleInt_i_Int__TupleTupleInt___getitem___self__Int___add___i_n__", + "rule_name": "pao_beta_0026_UF__n_Int_self_TupleTupleInt_i_Int__TupleTupleInt___getitem___self__Int___add___i_n__", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 52319, + "line": 1026, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 52319, + "end": 53254 + }, + "pattern_range": { + "start": 52490, + "end": 53037 + }, + "action_range": { + "start": 53047, + "end": 53247 + } + }, + "nodes": [ + { + "id": "cap0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "cap0: PaoInt", + "range": { + "start": 52507, + "end": 52539 + }, + "inputs": [] + }, + { + "id": "cap1", + "kind": "query_leaf", + "dsl_type": "PaoTupleTupleInt", + "label": "cap1: PaoTupleTupleInt", + "range": { + "start": 52552, + "end": 52594 + }, + "inputs": [] + }, + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__n_Int_self_TupleTupleInt_i_Int__TupleTupleInt___getitem___self__Int___add___i_n__", + "label": "closure: PaoUF__n_Int_self_TupleTupleInt_i_Int__TupleTupleInt___getitem___self__Int___add___i_n__", + "range": { + "start": 52607, + "end": 52731 + }, + "inputs": [ + "cap0", + "cap1" + ] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg0: PaoInt", + "range": { + "start": 52744, + "end": 52776 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_TupleInt_Int", + "label": "app: PaoUnstableApp__UnstableFn_TupleInt_Int", + "range": { + "start": 52789, + "end": 52863 + }, + "inputs": [ + "closure", + "arg0" + ] + } + ], + "edges": [ + { + "from": "closure", + "to": "cap0", + "kind": "operand", + "index": 0 + }, + { + "from": "closure", + "to": "cap1", + "kind": "operand", + "index": 1 + }, + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cap0", + "cap1", + "arg0", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@53082:53199", + "bound_var": "rhs", + "source_text": "ctx.insert_paon_int_self_tuple_tuple_int_i_int_tuple_tuple_int_getitem_self_int_add_i_n(pat.cap0, pat.cap1, pat.arg0)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "cap0", + "cap1" + ], + "referenced_action_vars": [], + "range": { + "start": 53082, + "end": 53199 + } + }, + { + "id": "effect_1", + "effect_id": "effect@53213:53236", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 53213, + "end": 53236 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0026_UF__n_Int_self_TupleTupleInt_i_Int__TupleTupleInt___getitem___self__Int___add___i_n__", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_TupleInt_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__n_Int_self_TupleTupleInt_i_Int__TupleTupleInt___getitem___self__Int___add___i_n__\")(cap0, cap1), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__n_Int_self_TupleTupleInt_i_Int__TupleTupleInt___getitem___self__Int___add___i_n__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaonIntSelfTupleTupleIntIIntTupleTupleIntGetitemSelfIntAddIN\")(cap0, cap1, arg0)", + "colored_source": "upright(\"PaonIntSelfTupleTupleIntIIntTupleTupleIntGetitemSelfIntAddIN\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_TupleInt_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__n_Int_self_TupleTupleInt_i_Int__TupleTupleInt___getitem___self__Int___add___i_n__\")(cap0, cap1), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__n_Int_self_TupleTupleInt_i_Int__TupleTupleInt___getitem___self__Int___add___i_n__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaonIntSelfTupleTupleIntIIntTupleTupleIntGetitemSelfIntAddIN\")(cap0, cap1, arg0)", + "colored_source": "upright(\"PaonIntSelfTupleTupleIntIIntTupleTupleIntGetitemSelfIntAddIN\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__n_Int_self_TupleTupleInt_i_Int__TupleTupleInt___getitem___self__Int___add___i_n__\")(cap0, cap1), arg0), upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__n_Int_self_TupleTupleInt_i_Int__TupleTupleInt___getitem___self__Int___add___i_n__\")(cap0, cap1), arg0) arrow.r.double upright(\"PaonIntSelfTupleTupleIntIIntTupleTupleIntGetitemSelfIntAddIN\")(cap0, cap1, arg0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__n_Int_self_TupleTupleInt_i_Int__TupleTupleInt___getitem___self__Int___add___i_n__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]), upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__n_Int_self_TupleTupleInt_i_Int__TupleTupleInt___getitem___self__Int___add___i_n__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]) arrow.r.double upright(\"PaonIntSelfTupleTupleIntIIntTupleTupleIntGetitemSelfIntAddIN\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__1043_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0027_UF_other_TupleTupleInt_self_TupleTupleInt_i_Int_TupleInt_if_Int_lt_i_TupleTupleInt_length_self_TupleTupleInt_getitem_self_i_TupleTupleInt_getitem_other_Int_sub_i_TupleTupleInt_length_self__7a0a82e934cac8eb", + "display_name": "pao_beta_0027_UF__other_TupleTupleInt_self_TupleTupleInt_i_Int__TupleInt_if___Int___lt___i__TupleTupleInt_length_self____TupleTupleInt___getitem___self_i___TupleTupleInt___getitem___other__Int___sub___i__TupleTupleInt_length_self____", + "rule_name": "pao_beta_0027_UF__other_TupleTupleInt_self_TupleTupleInt_i_Int__TupleInt_if___Int___lt___i__TupleTupleInt_length_self____TupleTupleInt___getitem___self_i___TupleTupleInt___getitem___other__Int___sub___i__TupleTupleInt_length_self____", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 53260, + "line": 1043, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 53260, + "end": 54607 + }, + "pattern_range": { + "start": 53565, + "end": 54266 + }, + "action_range": { + "start": 54276, + "end": 54600 + } + }, + "nodes": [ + { + "id": "cap0", + "kind": "query_leaf", + "dsl_type": "PaoTupleTupleInt", + "label": "cap0: PaoTupleTupleInt", + "range": { + "start": 53582, + "end": 53624 + }, + "inputs": [] + }, + { + "id": "cap1", + "kind": "query_leaf", + "dsl_type": "PaoTupleTupleInt", + "label": "cap1: PaoTupleTupleInt", + "range": { + "start": 53637, + "end": 53679 + }, + "inputs": [] + }, + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__other_TupleTupleInt_self_TupleTupleInt_i_Int__TupleInt_if___Int___lt___i__TupleTupleInt_length_self____TupleTupleInt___getitem___self_i___TupleTupleInt___getitem___other__Int___sub___i__TupleTupleInt_length_self____", + "label": "closure: PaoUF__other_TupleTupleInt_self_TupleTupleInt_i_Int__TupleInt_if___Int___lt___i__TupleTupleInt_length_self____TupleTupleInt___getitem___self_i___TupleTupleInt___getitem___other__Int___sub___i__TupleTupleInt_length_self____", + "range": { + "start": 53692, + "end": 53950 + }, + "inputs": [ + "cap0", + "cap1" + ] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg0: PaoInt", + "range": { + "start": 53963, + "end": 53995 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_TupleInt_Int", + "label": "app: PaoUnstableApp__UnstableFn_TupleInt_Int", + "range": { + "start": 54008, + "end": 54082 + }, + "inputs": [ + "closure", + "arg0" + ] + } + ], + "edges": [ + { + "from": "closure", + "to": "cap0", + "kind": "operand", + "index": 0 + }, + { + "from": "closure", + "to": "cap1", + "kind": "operand", + "index": 1 + }, + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cap0", + "cap1", + "arg0", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@54311:54552", + "bound_var": "rhs", + "source_text": "ctx.insert_paoother_tuple_tuple_int_self_tuple_tuple_int_i_int_tuple_int_if_int_lt_i_tuple_tuple_int_length_self_tuple_tuple_int_getitem_self_i_tuple_tuple_int_getitem_other_int_sub_i_tuple_tuple_int_length_self(pat.cap0, pat.cap1, pat.arg0)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "cap0", + "cap1" + ], + "referenced_action_vars": [], + "range": { + "start": 54311, + "end": 54552 + } + }, + { + "id": "effect_1", + "effect_id": "effect@54566:54589", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 54566, + "end": 54589 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0027_UF__other_TupleTupleInt_self_TupleTupleInt_i_Int__TupleInt_if___Int___lt___i__TupleTupleInt_length_self____TupleTupleInt___getitem___self_i___TupleTupleInt___getitem___other__Int___sub___i__TupleTupleInt_length_self____", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_TupleInt_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__other_TupleTupleInt_self_TupleTupleInt_i_Int__TupleInt_if___Int___lt___i__TupleTupleInt_length_self____TupleTupleInt___getitem___self_i___TupleTupleInt___getitem___other__Int___sub___i__TupleTupleInt_length_self____\")(cap0, cap1), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__other_TupleTupleInt_self_TupleTupleInt_i_Int__TupleInt_if___Int___lt___i__TupleTupleInt_length_self____TupleTupleInt___getitem___self_i___TupleTupleInt___getitem___other__Int___sub___i__TupleTupleInt_length_self____\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaootherTupleTupleIntSelfTupleTupleIntIIntTupleIntIfIntLtITupleTupleIntLengthSelfTupleTupleIntGetitemSelfITupleTupleIntGetitemOtherIntSubITupleTupleIntLengthSelf\")(cap0, cap1, arg0)", + "colored_source": "upright(\"PaootherTupleTupleIntSelfTupleTupleIntIIntTupleIntIfIntLtITupleTupleIntLengthSelfTupleTupleIntGetitemSelfITupleTupleIntGetitemOtherIntSubITupleTupleIntLengthSelf\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_TupleInt_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__other_TupleTupleInt_self_TupleTupleInt_i_Int__TupleInt_if___Int___lt___i__TupleTupleInt_length_self____TupleTupleInt___getitem___self_i___TupleTupleInt___getitem___other__Int___sub___i__TupleTupleInt_length_self____\")(cap0, cap1), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__other_TupleTupleInt_self_TupleTupleInt_i_Int__TupleInt_if___Int___lt___i__TupleTupleInt_length_self____TupleTupleInt___getitem___self_i___TupleTupleInt___getitem___other__Int___sub___i__TupleTupleInt_length_self____\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaootherTupleTupleIntSelfTupleTupleIntIIntTupleIntIfIntLtITupleTupleIntLengthSelfTupleTupleIntGetitemSelfITupleTupleIntGetitemOtherIntSubITupleTupleIntLengthSelf\")(cap0, cap1, arg0)", + "colored_source": "upright(\"PaootherTupleTupleIntSelfTupleTupleIntIIntTupleIntIfIntLtITupleTupleIntLengthSelfTupleTupleIntGetitemSelfITupleTupleIntGetitemOtherIntSubITupleTupleIntLengthSelf\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__other_TupleTupleInt_self_TupleTupleInt_i_Int__TupleInt_if___Int___lt___i__TupleTupleInt_length_self____TupleTupleInt___getitem___self_i___TupleTupleInt___getitem___other__Int___sub___i__TupleTupleInt_length_self____\")(cap0, cap1), arg0), upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__other_TupleTupleInt_self_TupleTupleInt_i_Int__TupleInt_if___Int___lt___i__TupleTupleInt_length_self____TupleTupleInt___getitem___self_i___TupleTupleInt___getitem___other__Int___sub___i__TupleTupleInt_length_self____\")(cap0, cap1), arg0) arrow.r.double upright(\"PaootherTupleTupleIntSelfTupleTupleIntIIntTupleIntIfIntLtITupleTupleIntLengthSelfTupleTupleIntGetitemSelfITupleTupleIntGetitemOtherIntSubITupleTupleIntLengthSelf\")(cap0, cap1, arg0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__other_TupleTupleInt_self_TupleTupleInt_i_Int__TupleInt_if___Int___lt___i__TupleTupleInt_length_self____TupleTupleInt___getitem___self_i___TupleTupleInt___getitem___other__Int___sub___i__TupleTupleInt_length_self____\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]), upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__other_TupleTupleInt_self_TupleTupleInt_i_Int__TupleInt_if___Int___lt___i__TupleTupleInt_length_self____TupleTupleInt___getitem___self_i___TupleTupleInt___getitem___other__Int___sub___i__TupleTupleInt_length_self____\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]) arrow.r.double upright(\"PaootherTupleTupleIntSelfTupleTupleIntIIntTupleIntIfIntLtITupleTupleIntLengthSelfTupleTupleIntGetitemSelfITupleTupleIntGetitemOtherIntSubITupleTupleIntLengthSelf\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__1060_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0028_UF_self_TupleTupleInt_i_Int_TupleInt_init_TupleTupleInt_length_self_unstable_fn_i_Int_self_TupleTupleInt_j_Int_TupleInt_getitem_TupleTupleInt_getitem_self_j_Int_mod_Int_floordiv_i_TupleInt_product_TupleTupleInt_map_int_TupleTupleInt_drop_self_Int_add_j_Int_init_1_unstable_fn_x_TupleInt_TupleInt_length_x_TupleInt_length_TupleTupleInt_getitem_self_j_i_self__cdc6701eb0841468", + "display_name": "pao_beta_0028_UF__self_TupleTupleInt_i_Int__TupleInt___init____TupleTupleInt_length_self___unstable_fn__i_Int_self_TupleTupleInt_j_Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable_fn__x_TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j______i_self__", + "rule_name": "pao_beta_0028_UF__self_TupleTupleInt_i_Int__TupleInt___init____TupleTupleInt_length_self___unstable_fn__i_Int_self_TupleTupleInt_j_Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable_fn__x_TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j______i_self__", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 54613, + "line": 1060, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 54613, + "end": 56452 + }, + "pattern_range": { + "start": 55124, + "end": 55945 + }, + "action_range": { + "start": 55955, + "end": 56445 + } + }, + "nodes": [ + { + "id": "cap0", + "kind": "query_leaf", + "dsl_type": "PaoTupleTupleInt", + "label": "cap0: PaoTupleTupleInt", + "range": { + "start": 55141, + "end": 55183 + }, + "inputs": [] + }, + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__self_TupleTupleInt_i_Int__TupleInt___init____TupleTupleInt_length_self___unstable_fn__i_Int_self_TupleTupleInt_j_Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable_fn__x_TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j______i_self__", + "label": "closure: PaoUF__self_TupleTupleInt_i_Int__TupleInt___init____TupleTupleInt_length_self___unstable_fn__i_Int_self_TupleTupleInt_j_Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable_fn__x_TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j______i_self__", + "range": { + "start": 55196, + "end": 55653 + }, + "inputs": [ + "cap0" + ] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg0: PaoInt", + "range": { + "start": 55666, + "end": 55698 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_TupleInt_Int", + "label": "app: PaoUnstableApp__UnstableFn_TupleInt_Int", + "range": { + "start": 55711, + "end": 55785 + }, + "inputs": [ + "closure", + "arg0" + ] + } + ], + "edges": [ + { + "from": "closure", + "to": "cap0", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cap0", + "arg0", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@55990:56397", + "bound_var": "rhs", + "source_text": "ctx.insert_paoself_tuple_tuple_int_i_int_tuple_int_init_tuple_tuple_int_length_self_unstable_fn_i_int_self_tuple_tuple_int_j_int_tuple_int_getitem_tuple_tuple_int_getitem_self_j_int_mod_int_floordiv_i_tuple_int_product_tuple_tuple_int_map_int_tuple_tuple_int_drop_self_int_add_j_int_init_1_unstable_fn_x_tuple_int_tuple_int_length_x_tuple_int_length_tuple_tuple_int_getitem_self_j_i_self(pat.cap0, pat.arg0)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "cap0" + ], + "referenced_action_vars": [], + "range": { + "start": 55990, + "end": 56397 + } + }, + { + "id": "effect_1", + "effect_id": "effect@56411:56434", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 56411, + "end": 56434 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0028_UF__self_TupleTupleInt_i_Int__TupleInt___init____TupleTupleInt_length_self___unstable_fn__i_Int_self_TupleTupleInt_j_Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable_fn__x_TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j______i_self__", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_TupleInt_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__self_TupleTupleInt_i_Int__TupleInt___init____TupleTupleInt_length_self___unstable_fn__i_Int_self_TupleTupleInt_j_Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable_fn__x_TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j______i_self__\")(cap0), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__self_TupleTupleInt_i_Int__TupleInt___init____TupleTupleInt_length_self___unstable_fn__i_Int_self_TupleTupleInt_j_Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable_fn__x_TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j______i_self__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoselfTupleTupleIntIIntTupleIntInitTupleTupleIntLengthSelfUnstableFnIIntSelfTupleTupleIntJIntTupleIntGetitemTupleTupleIntGetitemSelfJIntModIntFloordivITupleIntProductTupleTupleIntMapIntTupleTupleIntDropSelfIntAddJIntInit1UnstableFnXTupleIntTupleIntLengthXTupleIntLengthTupleTupleIntGetitemSelfJISelf\")(cap0, arg0)", + "colored_source": "upright(\"PaoselfTupleTupleIntIIntTupleIntInitTupleTupleIntLengthSelfUnstableFnIIntSelfTupleTupleIntJIntTupleIntGetitemTupleTupleIntGetitemSelfJIntModIntFloordivITupleIntProductTupleTupleIntMapIntTupleTupleIntDropSelfIntAddJIntInit1UnstableFnXTupleIntTupleIntLengthXTupleIntLengthTupleTupleIntGetitemSelfJISelf\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_TupleInt_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__self_TupleTupleInt_i_Int__TupleInt___init____TupleTupleInt_length_self___unstable_fn__i_Int_self_TupleTupleInt_j_Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable_fn__x_TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j______i_self__\")(cap0), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__self_TupleTupleInt_i_Int__TupleInt___init____TupleTupleInt_length_self___unstable_fn__i_Int_self_TupleTupleInt_j_Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable_fn__x_TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j______i_self__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaoselfTupleTupleIntIIntTupleIntInitTupleTupleIntLengthSelfUnstableFnIIntSelfTupleTupleIntJIntTupleIntGetitemTupleTupleIntGetitemSelfJIntModIntFloordivITupleIntProductTupleTupleIntMapIntTupleTupleIntDropSelfIntAddJIntInit1UnstableFnXTupleIntTupleIntLengthXTupleIntLengthTupleTupleIntGetitemSelfJISelf\")(cap0, arg0)", + "colored_source": "upright(\"PaoselfTupleTupleIntIIntTupleIntInitTupleTupleIntLengthSelfUnstableFnIIntSelfTupleTupleIntJIntTupleIntGetitemTupleTupleIntGetitemSelfJIntModIntFloordivITupleIntProductTupleTupleIntMapIntTupleTupleIntDropSelfIntAddJIntInit1UnstableFnXTupleIntTupleIntLengthXTupleIntLengthTupleTupleIntGetitemSelfJISelf\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__self_TupleTupleInt_i_Int__TupleInt___init____TupleTupleInt_length_self___unstable_fn__i_Int_self_TupleTupleInt_j_Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable_fn__x_TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j______i_self__\")(cap0), arg0), upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__self_TupleTupleInt_i_Int__TupleInt___init____TupleTupleInt_length_self___unstable_fn__i_Int_self_TupleTupleInt_j_Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable_fn__x_TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j______i_self__\")(cap0), arg0) arrow.r.double upright(\"PaoselfTupleTupleIntIIntTupleIntInitTupleTupleIntLengthSelfUnstableFnIIntSelfTupleTupleIntJIntTupleIntGetitemTupleTupleIntGetitemSelfJIntModIntFloordivITupleIntProductTupleTupleIntMapIntTupleTupleIntDropSelfIntAddJIntInit1UnstableFnXTupleIntTupleIntLengthXTupleIntLengthTupleTupleIntGetitemSelfJISelf\")(cap0, arg0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__self_TupleTupleInt_i_Int__TupleInt___init____TupleTupleInt_length_self___unstable_fn__i_Int_self_TupleTupleInt_j_Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable_fn__x_TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j______i_self__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]), upright(\"PaoUnstableApp__UnstableFn_TupleInt_Int\")(upright(\"PaoUF__self_TupleTupleInt_i_Int__TupleInt___init____TupleTupleInt_length_self___unstable_fn__i_Int_self_TupleTupleInt_j_Int__TupleInt___getitem____TupleTupleInt___getitem___self_j___Int___mod____Int___floordiv___i__TupleInt_product__TupleTupleInt_map_int__TupleTupleInt_drop_self__Int___add___j__Int___init___1_____unstable_fn__x_TupleInt__TupleInt_length_x________TupleInt_length__TupleTupleInt___getitem___self_j______i_self__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]) arrow.r.double upright(\"PaoselfTupleTupleIntIIntTupleIntInitTupleTupleIntLengthSelfUnstableFnIIntSelfTupleTupleIntJIntTupleIntGetitemTupleTupleIntGetitemSelfJIntModIntFloordivITupleIntProductTupleTupleIntMapIntTupleTupleIntDropSelfIntAddJIntInit1UnstableFnXTupleIntTupleIntLengthXTupleIntLengthTupleTupleIntGetitemSelfJISelf\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__1076_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0029_UF_f_UnstableFn_Boolean_Int_acc_TupleInt_v_Int_TupleInt_if_unstable_app_f_v_TupleInt_append_acc_v_acc__7e02c2c1db191f36", + "display_name": "pao_beta_0029_UF__f_UnstableFn_Boolean_Int_acc_TupleInt_v_Int__TupleInt_if___unstable_app_f_v___TupleInt_append_acc_v__acc_", + "rule_name": "pao_beta_0029_UF__f_UnstableFn_Boolean_Int_acc_TupleInt_v_Int__TupleInt_if___unstable_app_f_v___TupleInt_append_acc_v__acc_", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 56458, + "line": 1076, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 56458, + "end": 57516 + }, + "pattern_range": { + "start": 56653, + "end": 57270 + }, + "action_range": { + "start": 57280, + "end": 57509 + } + }, + "nodes": [ + { + "id": "cap0", + "kind": "query_leaf", + "dsl_type": "PaoUnstableFn_Boolean_Int", + "label": "cap0: PaoUnstableFn_Boolean_Int", + "range": { + "start": 56670, + "end": 56721 + }, + "inputs": [] + }, + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__f_UnstableFn_Boolean_Int_acc_TupleInt_v_Int__TupleInt_if___unstable_app_f_v___TupleInt_append_acc_v__acc_", + "label": "closure: PaoUF__f_UnstableFn_Boolean_Int_acc_TupleInt_v_Int__TupleInt_if___unstable_app_f_v___TupleInt_append_acc_v__acc_", + "range": { + "start": 56734, + "end": 56875 + }, + "inputs": [ + "cap0" + ] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoTupleInt", + "label": "arg0: PaoTupleInt", + "range": { + "start": 56888, + "end": 56925 + }, + "inputs": [] + }, + { + "id": "arg1", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg1: PaoInt", + "range": { + "start": 56938, + "end": 56970 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_TupleInt_TupleInt_Int", + "label": "app: PaoUnstableApp__UnstableFn_TupleInt_TupleInt_Int", + "range": { + "start": 56983, + "end": 57073 + }, + "inputs": [ + "closure", + "arg0", + "arg1" + ] + } + ], + "edges": [ + { + "from": "closure", + "to": "cap0", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + }, + { + "from": "app", + "to": "arg1", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "cap0", + "arg0", + "arg1", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@57315:57461", + "bound_var": "rhs", + "source_text": "ctx.insert_paof_unstable_fn_boolean_int_acc_tuple_int_v_int_tuple_int_if_unstable_app_f_v_tuple_int_append_acc_v_acc(pat.cap0, pat.arg0, pat.arg1)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "arg1", + "cap0" + ], + "referenced_action_vars": [], + "range": { + "start": 57315, + "end": 57461 + } + }, + { + "id": "effect_1", + "effect_id": "effect@57475:57498", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 57475, + "end": 57498 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0029_UF__f_UnstableFn_Boolean_Int_acc_TupleInt_v_Int__TupleInt_if___unstable_app_f_v___TupleInt_append_acc_v__acc_", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_TupleInt_TupleInt_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_TupleInt_Int\")(upright(\"PaoUF__f_UnstableFn_Boolean_Int_acc_TupleInt_v_Int__TupleInt_if___unstable_app_f_v___TupleInt_append_acc_v__acc_\")(cap0), arg0, arg1)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_TupleInt_Int\")(upright(\"PaoUF__f_UnstableFn_Boolean_Int_acc_TupleInt_v_Int__TupleInt_if___unstable_app_f_v___TupleInt_append_acc_v__acc_\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaofUnstableFnBooleanIntAccTupleIntVIntTupleIntIfUnstableAppFVTupleIntAppendAccVAcc\")(cap0, arg0, arg1)", + "colored_source": "upright(\"PaofUnstableFnBooleanIntAccTupleIntVIntTupleIntIfUnstableAppFVTupleIntAppendAccVAcc\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_TupleInt_TupleInt_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_TupleInt_Int\")(upright(\"PaoUF__f_UnstableFn_Boolean_Int_acc_TupleInt_v_Int__TupleInt_if___unstable_app_f_v___TupleInt_append_acc_v__acc_\")(cap0), arg0, arg1)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_TupleInt_TupleInt_Int\")(upright(\"PaoUF__f_UnstableFn_Boolean_Int_acc_TupleInt_v_Int__TupleInt_if___unstable_app_f_v___TupleInt_append_acc_v__acc_\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaofUnstableFnBooleanIntAccTupleIntVIntTupleIntIfUnstableAppFVTupleIntAppendAccVAcc\")(cap0, arg0, arg1)", + "colored_source": "upright(\"PaofUnstableFnBooleanIntAccTupleIntVIntTupleIntIfUnstableAppFVTupleIntAppendAccVAcc\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_TupleInt_TupleInt_Int\")(upright(\"PaoUF__f_UnstableFn_Boolean_Int_acc_TupleInt_v_Int__TupleInt_if___unstable_app_f_v___TupleInt_append_acc_v__acc_\")(cap0), arg0, arg1), upright(\"PaoUnstableApp__UnstableFn_TupleInt_TupleInt_Int\")(upright(\"PaoUF__f_UnstableFn_Boolean_Int_acc_TupleInt_v_Int__TupleInt_if___unstable_app_f_v___TupleInt_append_acc_v__acc_\")(cap0), arg0, arg1) arrow.r.double upright(\"PaofUnstableFnBooleanIntAccTupleIntVIntTupleIntIfUnstableAppFVTupleIntAppendAccVAcc\")(cap0, arg0, arg1)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_TupleInt_TupleInt_Int\")(upright(\"PaoUF__f_UnstableFn_Boolean_Int_acc_TupleInt_v_Int__TupleInt_if___unstable_app_f_v___TupleInt_append_acc_v__acc_\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $]), upright(\"PaoUnstableApp__UnstableFn_TupleInt_TupleInt_Int\")(upright(\"PaoUF__f_UnstableFn_Boolean_Int_acc_TupleInt_v_Int__TupleInt_if___unstable_app_f_v___TupleInt_append_acc_v__acc_\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $]) arrow.r.double upright(\"PaofUnstableFnBooleanIntAccTupleIntVIntTupleIntIfUnstableAppFVTupleIntAppendAccVAcc\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg1 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__1093_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0030_UF_other_TupleValue_self_TupleValue_i_Int_Value_if_Int_lt_i_TupleValue_length_self_TupleValue_getitem_self_i_TupleValue_getitem_other_Int_sub_i_TupleValue_length_self__7a68601cee7c40b6", + "display_name": "pao_beta_0030_UF__other_TupleValue_self_TupleValue_i_Int__Value_if___Int___lt___i__TupleValue_length_self____TupleValue___getitem___self_i___TupleValue___getitem___other__Int___sub___i__TupleValue_length_self____", + "rule_name": "pao_beta_0030_UF__other_TupleValue_self_TupleValue_i_Int__Value_if___Int___lt___i__TupleValue_length_self____TupleValue___getitem___self_i___TupleValue___getitem___other__Int___sub___i__TupleValue_length_self____", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 57522, + "line": 1093, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 57522, + "end": 58781 + }, + "pattern_range": { + "start": 57806, + "end": 58468 + }, + "action_range": { + "start": 58478, + "end": 58774 + } + }, + "nodes": [ + { + "id": "cap0", + "kind": "query_leaf", + "dsl_type": "PaoTupleValue", + "label": "cap0: PaoTupleValue", + "range": { + "start": 57823, + "end": 57862 + }, + "inputs": [] + }, + { + "id": "cap1", + "kind": "query_leaf", + "dsl_type": "PaoTupleValue", + "label": "cap1: PaoTupleValue", + "range": { + "start": 57875, + "end": 57914 + }, + "inputs": [] + }, + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__other_TupleValue_self_TupleValue_i_Int__Value_if___Int___lt___i__TupleValue_length_self____TupleValue___getitem___self_i___TupleValue___getitem___other__Int___sub___i__TupleValue_length_self____", + "label": "closure: PaoUF__other_TupleValue_self_TupleValue_i_Int__Value_if___Int___lt___i__TupleValue_length_self____TupleValue___getitem___self_i___TupleValue___getitem___other__Int___sub___i__TupleValue_length_self____", + "range": { + "start": 57927, + "end": 58164 + }, + "inputs": [ + "cap0", + "cap1" + ] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg0: PaoInt", + "range": { + "start": 58177, + "end": 58209 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_Value_Int", + "label": "app: PaoUnstableApp__UnstableFn_Value_Int", + "range": { + "start": 58222, + "end": 58293 + }, + "inputs": [ + "closure", + "arg0" + ] + } + ], + "edges": [ + { + "from": "closure", + "to": "cap0", + "kind": "operand", + "index": 0 + }, + { + "from": "closure", + "to": "cap1", + "kind": "operand", + "index": 1 + }, + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cap0", + "cap1", + "arg0", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@58513:58726", + "bound_var": "rhs", + "source_text": "ctx.insert_paoother_tuple_value_self_tuple_value_i_int_value_if_int_lt_i_tuple_value_length_self_tuple_value_getitem_self_i_tuple_value_getitem_other_int_sub_i_tuple_value_length_self(pat.cap0, pat.cap1, pat.arg0)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "cap0", + "cap1" + ], + "referenced_action_vars": [], + "range": { + "start": 58513, + "end": 58726 + } + }, + { + "id": "effect_1", + "effect_id": "effect@58740:58763", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 58740, + "end": 58763 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0030_UF__other_TupleValue_self_TupleValue_i_Int__Value_if___Int___lt___i__TupleValue_length_self____TupleValue___getitem___self_i___TupleValue___getitem___other__Int___sub___i__TupleValue_length_self____", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Value_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Value_Int\")(upright(\"PaoUF__other_TupleValue_self_TupleValue_i_Int__Value_if___Int___lt___i__TupleValue_length_self____TupleValue___getitem___self_i___TupleValue___getitem___other__Int___sub___i__TupleValue_length_self____\")(cap0, cap1), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Value_Int\")(upright(\"PaoUF__other_TupleValue_self_TupleValue_i_Int__Value_if___Int___lt___i__TupleValue_length_self____TupleValue___getitem___self_i___TupleValue___getitem___other__Int___sub___i__TupleValue_length_self____\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaootherTupleValueSelfTupleValueIIntValueIfIntLtITupleValueLengthSelfTupleValueGetitemSelfITupleValueGetitemOtherIntSubITupleValueLengthSelf\")(cap0, cap1, arg0)", + "colored_source": "upright(\"PaootherTupleValueSelfTupleValueIIntValueIfIntLtITupleValueLengthSelfTupleValueGetitemSelfITupleValueGetitemOtherIntSubITupleValueLengthSelf\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Value_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Value_Int\")(upright(\"PaoUF__other_TupleValue_self_TupleValue_i_Int__Value_if___Int___lt___i__TupleValue_length_self____TupleValue___getitem___self_i___TupleValue___getitem___other__Int___sub___i__TupleValue_length_self____\")(cap0, cap1), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Value_Int\")(upright(\"PaoUF__other_TupleValue_self_TupleValue_i_Int__Value_if___Int___lt___i__TupleValue_length_self____TupleValue___getitem___self_i___TupleValue___getitem___other__Int___sub___i__TupleValue_length_self____\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaootherTupleValueSelfTupleValueIIntValueIfIntLtITupleValueLengthSelfTupleValueGetitemSelfITupleValueGetitemOtherIntSubITupleValueLengthSelf\")(cap0, cap1, arg0)", + "colored_source": "upright(\"PaootherTupleValueSelfTupleValueIIntValueIfIntLtITupleValueLengthSelfTupleValueGetitemSelfITupleValueGetitemOtherIntSubITupleValueLengthSelf\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_Value_Int\")(upright(\"PaoUF__other_TupleValue_self_TupleValue_i_Int__Value_if___Int___lt___i__TupleValue_length_self____TupleValue___getitem___self_i___TupleValue___getitem___other__Int___sub___i__TupleValue_length_self____\")(cap0, cap1), arg0), upright(\"PaoUnstableApp__UnstableFn_Value_Int\")(upright(\"PaoUF__other_TupleValue_self_TupleValue_i_Int__Value_if___Int___lt___i__TupleValue_length_self____TupleValue___getitem___self_i___TupleValue___getitem___other__Int___sub___i__TupleValue_length_self____\")(cap0, cap1), arg0) arrow.r.double upright(\"PaootherTupleValueSelfTupleValueIIntValueIfIntLtITupleValueLengthSelfTupleValueGetitemSelfITupleValueGetitemOtherIntSubITupleValueLengthSelf\")(cap0, cap1, arg0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_Value_Int\")(upright(\"PaoUF__other_TupleValue_self_TupleValue_i_Int__Value_if___Int___lt___i__TupleValue_length_self____TupleValue___getitem___self_i___TupleValue___getitem___other__Int___sub___i__TupleValue_length_self____\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]), upright(\"PaoUnstableApp__UnstableFn_Value_Int\")(upright(\"PaoUF__other_TupleValue_self_TupleValue_i_Int__Value_if___Int___lt___i__TupleValue_length_self____TupleValue___getitem___self_i___TupleValue___getitem___other__Int___sub___i__TupleValue_length_self____\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]) arrow.r.double upright(\"PaootherTupleValueSelfTupleValueIIntValueIfIntLtITupleValueLengthSelfTupleValueGetitemSelfITupleValueGetitemOtherIntSubITupleValueLengthSelf\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__1110_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0031_UF_ti_TupleInt_i_Int_Value_int_TupleInt_getitem_ti_i__8b5b30058493a5c6", + "display_name": "pao_beta_0031_UF__ti_TupleInt_i_Int__Value_int__TupleInt___getitem___ti_i__", + "rule_name": "pao_beta_0031_UF__ti_TupleInt_i_Int__Value_int__TupleInt___getitem___ti_i__", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 58787, + "line": 1110, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 58787, + "end": 59560 + }, + "pattern_range": { + "start": 58934, + "end": 59375 + }, + "action_range": { + "start": 59385, + "end": 59553 + } + }, + "nodes": [ + { + "id": "cap0", + "kind": "query_leaf", + "dsl_type": "PaoTupleInt", + "label": "cap0: PaoTupleInt", + "range": { + "start": 58951, + "end": 58988 + }, + "inputs": [] + }, + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__ti_TupleInt_i_Int__Value_int__TupleInt___getitem___ti_i__", + "label": "closure: PaoUF__ti_TupleInt_i_Int__Value_int__TupleInt___getitem___ti_i__", + "range": { + "start": 59001, + "end": 59094 + }, + "inputs": [ + "cap0" + ] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg0: PaoInt", + "range": { + "start": 59107, + "end": 59139 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_Value_Int", + "label": "app: PaoUnstableApp__UnstableFn_Value_Int", + "range": { + "start": 59152, + "end": 59223 + }, + "inputs": [ + "closure", + "arg0" + ] + } + ], + "edges": [ + { + "from": "closure", + "to": "cap0", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cap0", + "arg0", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@59420:59505", + "bound_var": "rhs", + "source_text": "ctx.insert_paoti_tuple_int_i_int_value_int_tuple_int_getitem_ti_i(pat.cap0, pat.arg0)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "cap0" + ], + "referenced_action_vars": [], + "range": { + "start": 59420, + "end": 59505 + } + }, + { + "id": "effect_1", + "effect_id": "effect@59519:59542", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 59519, + "end": 59542 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0031_UF__ti_TupleInt_i_Int__Value_int__TupleInt___getitem___ti_i__", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Value_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Value_Int\")(upright(\"PaoUF__ti_TupleInt_i_Int__Value_int__TupleInt___getitem___ti_i__\")(cap0), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Value_Int\")(upright(\"PaoUF__ti_TupleInt_i_Int__Value_int__TupleInt___getitem___ti_i__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaotiTupleIntIIntValueIntTupleIntGetitemTiI\")(cap0, arg0)", + "colored_source": "upright(\"PaotiTupleIntIIntValueIntTupleIntGetitemTiI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Value_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Value_Int\")(upright(\"PaoUF__ti_TupleInt_i_Int__Value_int__TupleInt___getitem___ti_i__\")(cap0), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Value_Int\")(upright(\"PaoUF__ti_TupleInt_i_Int__Value_int__TupleInt___getitem___ti_i__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaotiTupleIntIIntValueIntTupleIntGetitemTiI\")(cap0, arg0)", + "colored_source": "upright(\"PaotiTupleIntIIntValueIntTupleIntGetitemTiI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_Value_Int\")(upright(\"PaoUF__ti_TupleInt_i_Int__Value_int__TupleInt___getitem___ti_i__\")(cap0), arg0), upright(\"PaoUnstableApp__UnstableFn_Value_Int\")(upright(\"PaoUF__ti_TupleInt_i_Int__Value_int__TupleInt___getitem___ti_i__\")(cap0), arg0) arrow.r.double upright(\"PaotiTupleIntIIntValueIntTupleIntGetitemTiI\")(cap0, arg0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_Value_Int\")(upright(\"PaoUF__ti_TupleInt_i_Int__Value_int__TupleInt___getitem___ti_i__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]), upright(\"PaoUnstableApp__UnstableFn_Value_Int\")(upright(\"PaoUF__ti_TupleInt_i_Int__Value_int__TupleInt___getitem___ti_i__\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]) arrow.r.double upright(\"PaotiTupleIntIIntValueIntTupleIntGetitemTiI\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__1126_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0032_UF_values_TupleValue_x_NDArray_i_Int_NDArray_to_value_sum_NDArray_eq_x_NDArray_scalar_TupleValue_getitem_values_i_OptionalIntOrTuple_none__875bbf54de75e8ad", + "display_name": "pao_beta_0032_UF__values_TupleValue_x_NDArray_i_Int__NDArray_to_value__sum__NDArray___eq___x__NDArray_scalar__TupleValue___getitem___values_i_____OptionalIntOrTuple_none____", + "rule_name": "pao_beta_0032_UF__values_TupleValue_x_NDArray_i_Int__NDArray_to_value__sum__NDArray___eq___x__NDArray_scalar__TupleValue___getitem___values_i_____OptionalIntOrTuple_none____", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 59566, + "line": 1126, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 59566, + "end": 60715 + }, + "pattern_range": { + "start": 59811, + "end": 60428 + }, + "action_range": { + "start": 60438, + "end": 60708 + } + }, + "nodes": [ + { + "id": "cap0", + "kind": "query_leaf", + "dsl_type": "PaoTupleValue", + "label": "cap0: PaoTupleValue", + "range": { + "start": 59828, + "end": 59867 + }, + "inputs": [] + }, + { + "id": "cap1", + "kind": "query_leaf", + "dsl_type": "PaoNDArray", + "label": "cap1: PaoNDArray", + "range": { + "start": 59880, + "end": 59916 + }, + "inputs": [] + }, + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__values_TupleValue_x_NDArray_i_Int__NDArray_to_value__sum__NDArray___eq___x__NDArray_scalar__TupleValue___getitem___values_i_____OptionalIntOrTuple_none____", + "label": "closure: PaoUF__values_TupleValue_x_NDArray_i_Int__NDArray_to_value__sum__NDArray___eq___x__NDArray_scalar__TupleValue___getitem___values_i_____OptionalIntOrTuple_none____", + "range": { + "start": 59929, + "end": 60127 + }, + "inputs": [ + "cap0", + "cap1" + ] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoInt", + "label": "arg0: PaoInt", + "range": { + "start": 60140, + "end": 60172 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_Value_Int", + "label": "app: PaoUnstableApp__UnstableFn_Value_Int", + "range": { + "start": 60185, + "end": 60256 + }, + "inputs": [ + "closure", + "arg0" + ] + } + ], + "edges": [ + { + "from": "closure", + "to": "cap0", + "kind": "operand", + "index": 0 + }, + { + "from": "closure", + "to": "cap1", + "kind": "operand", + "index": 1 + }, + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cap0", + "cap1", + "arg0", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@60473:60660", + "bound_var": "rhs", + "source_text": "ctx.insert_paovalues_tuple_value_x_nd_array_i_int_nd_array_to_value_sum_nd_array_eq_x_nd_array_scalar_tuple_value_getitem_values_i_optional_int_or_tuple_none(pat.cap0, pat.cap1, pat.arg0)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "cap0", + "cap1" + ], + "referenced_action_vars": [], + "range": { + "start": 60473, + "end": 60660 + } + }, + { + "id": "effect_1", + "effect_id": "effect@60674:60697", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 60674, + "end": 60697 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0032_UF__values_TupleValue_x_NDArray_i_Int__NDArray_to_value__sum__NDArray___eq___x__NDArray_scalar__TupleValue___getitem___values_i_____OptionalIntOrTuple_none____", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Value_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Value_Int\")(upright(\"PaoUF__values_TupleValue_x_NDArray_i_Int__NDArray_to_value__sum__NDArray___eq___x__NDArray_scalar__TupleValue___getitem___values_i_____OptionalIntOrTuple_none____\")(cap0, cap1), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Value_Int\")(upright(\"PaoUF__values_TupleValue_x_NDArray_i_Int__NDArray_to_value__sum__NDArray___eq___x__NDArray_scalar__TupleValue___getitem___values_i_____OptionalIntOrTuple_none____\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaovaluesTupleValueXNdArrayIIntNdArrayToValueSumNdArrayEqXNdArrayScalarTupleValueGetitemValuesIOptionalIntOrTupleNone\")(cap0, cap1, arg0)", + "colored_source": "upright(\"PaovaluesTupleValueXNdArrayIIntNdArrayToValueSumNdArrayEqXNdArrayScalarTupleValueGetitemValuesIOptionalIntOrTupleNone\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Value_Int", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Value_Int\")(upright(\"PaoUF__values_TupleValue_x_NDArray_i_Int__NDArray_to_value__sum__NDArray___eq___x__NDArray_scalar__TupleValue___getitem___values_i_____OptionalIntOrTuple_none____\")(cap0, cap1), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Value_Int\")(upright(\"PaoUF__values_TupleValue_x_NDArray_i_Int__NDArray_to_value__sum__NDArray___eq___x__NDArray_scalar__TupleValue___getitem___values_i_____OptionalIntOrTuple_none____\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaovaluesTupleValueXNdArrayIIntNdArrayToValueSumNdArrayEqXNdArrayScalarTupleValueGetitemValuesIOptionalIntOrTupleNone\")(cap0, cap1, arg0)", + "colored_source": "upright(\"PaovaluesTupleValueXNdArrayIIntNdArrayToValueSumNdArrayEqXNdArrayScalarTupleValueGetitemValuesIOptionalIntOrTupleNone\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_Value_Int\")(upright(\"PaoUF__values_TupleValue_x_NDArray_i_Int__NDArray_to_value__sum__NDArray___eq___x__NDArray_scalar__TupleValue___getitem___values_i_____OptionalIntOrTuple_none____\")(cap0, cap1), arg0), upright(\"PaoUnstableApp__UnstableFn_Value_Int\")(upright(\"PaoUF__values_TupleValue_x_NDArray_i_Int__NDArray_to_value__sum__NDArray___eq___x__NDArray_scalar__TupleValue___getitem___values_i_____OptionalIntOrTuple_none____\")(cap0, cap1), arg0) arrow.r.double upright(\"PaovaluesTupleValueXNdArrayIIntNdArrayToValueSumNdArrayEqXNdArrayScalarTupleValueGetitemValuesIOptionalIntOrTupleNone\")(cap0, cap1, arg0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_Value_Int\")(upright(\"PaoUF__values_TupleValue_x_NDArray_i_Int__NDArray_to_value__sum__NDArray___eq___x__NDArray_scalar__TupleValue___getitem___values_i_____OptionalIntOrTuple_none____\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]), upright(\"PaoUnstableApp__UnstableFn_Value_Int\")(upright(\"PaoUF__values_TupleValue_x_NDArray_i_Int__NDArray_to_value__sum__NDArray___eq___x__NDArray_scalar__TupleValue___getitem___values_i_____OptionalIntOrTuple_none____\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]) arrow.r.double upright(\"PaovaluesTupleValueXNdArrayIIntNdArrayToValueSumNdArrayEqXNdArrayScalarTupleValueGetitemValuesIOptionalIntOrTupleNone\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ cap1 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_python_array_optimize_rs__1143_5_MyTxPythonArrayOptimize_add_rule__pao_beta_0033_UF_value_Value_TupleInt_value__dfb04f63315df1ec", + "display_name": "pao_beta_0033_UF__value_Value___TupleInt_value", + "rule_name": "pao_beta_0033_UF__value_Value___TupleInt_value", + "callee": "MyTxPythonArrayOptimize::add_rule", + "file": "benches/runners/generated/.python_array_optimize.rs", + "offset": 60721, + "line": 1143, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 60721, + "end": 61426 + }, + "pattern_range": { + "start": 60839, + "end": 61265 + }, + "action_range": { + "start": 61275, + "end": 61419 + } + }, + "nodes": [ + { + "id": "cap0", + "kind": "query_leaf", + "dsl_type": "PaoValue", + "label": "cap0: PaoValue", + "range": { + "start": 60856, + "end": 60890 + }, + "inputs": [] + }, + { + "id": "closure", + "kind": "query", + "dsl_type": "PaoUF__value_Value___TupleInt_value", + "label": "closure: PaoUF__value_Value___TupleInt_value", + "range": { + "start": 60903, + "end": 60967 + }, + "inputs": [ + "cap0" + ] + }, + { + "id": "arg0", + "kind": "query_leaf", + "dsl_type": "PaoTupleInt", + "label": "arg0: PaoTupleInt", + "range": { + "start": 60980, + "end": 61017 + }, + "inputs": [] + }, + { + "id": "app", + "kind": "query", + "dsl_type": "PaoUnstableApp__UnstableFn_Value_TupleInt", + "label": "app: PaoUnstableApp__UnstableFn_Value_TupleInt", + "range": { + "start": 61030, + "end": 61106 + }, + "inputs": [ + "closure", + "arg0" + ] + } + ], + "edges": [ + { + "from": "closure", + "to": "cap0", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "closure", + "kind": "operand", + "index": 0 + }, + { + "from": "app", + "to": "arg0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cap0", + "arg0", + "app" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@61310:61371", + "bound_var": "rhs", + "source_text": "ctx.insert_paovalue_value_tuple_int_value(pat.cap0, pat.arg0)", + "semantic_text": null, + "referenced_pat_vars": [ + "arg0", + "cap0" + ], + "referenced_action_vars": [], + "range": { + "start": 61310, + "end": 61371 + } + }, + { + "id": "effect_1", + "effect_id": "effect@61385:61408", + "bound_var": null, + "source_text": "ctx.union(pat.app, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "app" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 61385, + "end": 61408 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "pao_beta_0033_UF__value_Value___TupleInt_value", + "premises": [ + { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Value_TupleInt", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Value_TupleInt\")(upright(\"PaoUF__value_Value___TupleInt_value\")(cap0), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Value_TupleInt\")(upright(\"PaoUF__value_Value___TupleInt_value\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaovalueValueTupleIntValue\")(cap0, arg0)", + "colored_source": "upright(\"PaovalueValueTupleIntValue\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "app", + "label": "app: PaoUnstableApp__UnstableFn_Value_TupleInt", + "plain_source": "upright(\"PaoUnstableApp__UnstableFn_Value_TupleInt\")(upright(\"PaoUF__value_Value___TupleInt_value\")(cap0), arg0)", + "colored_source": "upright(\"PaoUnstableApp__UnstableFn_Value_TupleInt\")(upright(\"PaoUF__value_Value___TupleInt_value\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "upright(\"PaovalueValueTupleIntValue\")(cap0, arg0)", + "colored_source": "upright(\"PaovalueValueTupleIntValue\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PaoUnstableApp__UnstableFn_Value_TupleInt\")(upright(\"PaoUF__value_Value___TupleInt_value\")(cap0), arg0), upright(\"PaoUnstableApp__UnstableFn_Value_TupleInt\")(upright(\"PaoUF__value_Value___TupleInt_value\")(cap0), arg0) arrow.r.double upright(\"PaovalueValueTupleIntValue\")(cap0, arg0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"PaoUnstableApp__UnstableFn_Value_TupleInt\")(upright(\"PaoUF__value_Value___TupleInt_value\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]), upright(\"PaoUnstableApp__UnstableFn_Value_TupleInt\")(upright(\"PaoUF__value_Value___TupleInt_value\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $]) arrow.r.double upright(\"PaovalueValueTupleIntValue\")(#text(fill: rgb(\"#5F7A8A\"))[$ cap0 $], #text(fill: rgb(\"#5F7A8A\"))[$ arg0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6613_5_MyTxEggccExtraction_add_rule__r0001__fb10149ebb1dba86", + "display_name": "r0001", + "rule_name": "r0001", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 193908, + "line": 6613, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 193908, + "end": 194218 + }, + "pattern_range": { + "start": 193953, + "end": 193964 + }, + "action_range": { + "start": 193966, + "end": 194217 + } + }, + "nodes": [ + { + "id": "x", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "x: EcxVecOperandBase", + "range": { + "start": 19065, + "end": 19105 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t1: EcxVO", + "range": { + "start": 19110, + "end": 19137 + }, + "inputs": [ + "x" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t3: EcxVO", + "range": { + "start": 19142, + "end": 19169 + }, + "inputs": [ + "x" + ] + }, + { + "id": "_f2", + "kind": "query", + "dsl_type": "EcxVecOperand_length", + "label": "_f2: EcxVecOperand_length", + "range": { + "start": 19174, + "end": 19218 + }, + "inputs": [ + "_t3" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "x", + "kind": "operand", + "index": 0 + }, + { + "from": "_t3", + "to": "x", + "kind": "operand", + "index": 0 + }, + { + "from": "_f2", + "to": "_t3", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "x", + "_t1", + "_f2", + "_t3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "_f2.handle().gt(&(&(0_i64)).as_handle())", + "semantic_text": "_f2 > 0", + "referenced_vars": [ + "_f2" + ], + "range": { + "start": 19316, + "end": 19318 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@193996:194020", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_vo(pat.x)", + "semantic_text": null, + "referenced_pat_vars": [ + "x" + ], + "referenced_action_vars": [], + "range": { + "start": 193996, + "end": 194020 + } + }, + { + "id": "effect_1", + "effect_id": "effect@194039:194080", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_vec_operand_get(t2, 0_i64)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 194039, + "end": 194080 + } + }, + { + "id": "effect_2", + "effect_id": "effect@194099:194123", + "bound_var": "t4", + "source_text": "ctx.insert_ecx_vo(pat.x)", + "semantic_text": null, + "referenced_pat_vars": [ + "x" + ], + "referenced_action_vars": [], + "range": { + "start": 194099, + "end": 194123 + } + }, + { + "id": "effect_3", + "effect_id": "effect@194142:194183", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_vec_operand_get(t4, 0_i64)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t4" + ], + "range": { + "start": 194142, + "end": 194183 + } + }, + { + "id": "effect_4", + "effect_id": "effect@194193:194210", + "bound_var": null, + "source_text": "ctx.union(t1, t3)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t1", + "t3" + ], + "range": { + "start": 194193, + "end": 194210 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0001", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxVO", + "plain_source": "upright(\"VO\")(x)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $]" + }, + { + "target_id": "_f2", + "label": "_f2: EcxVecOperand_length", + "plain_source": "upright(\"EcxVecOperand_length\")(upright(\"VO\")(x))", + "colored_source": "upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $])" + }, + { + "target_id": "_t3", + "label": "_t3: EcxVO", + "plain_source": "upright(\"VO\")(x)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $]" + } + ], + "side_conditions": [ + "upright(\"_f2\") > 0" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"VO\")(x) \\ upright(\"EcxVecOperand_length\")(upright(\"VO\")(x)) \\ upright(\"VO\")(x), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"_f2\") > 0", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $] \\ upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"_f2\") > 0" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6620_5_MyTxEggccExtraction_add_rule__r0002__d4178f8d6d7dc975", + "display_name": "r0002", + "rule_name": "r0002", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 194224, + "line": 6620, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 194224, + "end": 194560 + }, + "pattern_range": { + "start": 194269, + "end": 194280 + }, + "action_range": { + "start": 194282, + "end": 194559 + } + }, + "nodes": [ + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 19557, + "end": 19602 + }, + "inputs": [] + }, + { + "id": "j", + "kind": "query", + "dsl_type": "", + "label": "j: ", + "range": { + "start": 19607, + "end": 19652 + }, + "inputs": [] + }, + { + "id": "x", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "x: EcxVecOperandBase", + "range": { + "start": 19657, + "end": 19697 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t2: EcxVO", + "range": { + "start": 19702, + "end": 19729 + }, + "inputs": [ + "x" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxVecOperand_get", + "label": "_t1: EcxVecOperand_get", + "range": { + "start": 19734, + "end": 19775 + }, + "inputs": [ + "_t2" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t4: EcxVO", + "range": { + "start": 19780, + "end": 19807 + }, + "inputs": [ + "x" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxVecOperand_length", + "label": "_f3: EcxVecOperand_length", + "range": { + "start": 19812, + "end": 19856 + }, + "inputs": [ + "_t4" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "x", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "x", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "_t4", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "i", + "j", + "x", + "_t1", + "_t2", + "_f3", + "_t4" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "j.handle().eq(&_t1.handle_a1())", + "semantic_text": "j == _t1.a1", + "referenced_vars": [ + "_t1", + "j" + ], + "range": { + "start": 20076, + "end": 20078 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "i.handle().eq(&(j.handle() + (&(1_i64)).as_handle()))", + "semantic_text": "i == j + 1", + "referenced_vars": [ + "i", + "j" + ], + "range": { + "start": 20096, + "end": 20098 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "i.handle().lt(&_f3.handle())", + "semantic_text": "i < _f3", + "referenced_vars": [ + "_f3", + "i" + ], + "range": { + "start": 20116, + "end": 20118 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@194312:194336", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_vo(pat.x)", + "semantic_text": null, + "referenced_pat_vars": [ + "x" + ], + "referenced_action_vars": [], + "range": { + "start": 194312, + "end": 194336 + } + }, + { + "id": "effect_1", + "effect_id": "effect@194355:194409", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_vec_operand_get(t2, ctx.devalue(pat.i))", + "semantic_text": null, + "referenced_pat_vars": [ + "i" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 194355, + "end": 194409 + } + }, + { + "id": "effect_2", + "effect_id": "effect@194428:194452", + "bound_var": "t4", + "source_text": "ctx.insert_ecx_vo(pat.x)", + "semantic_text": null, + "referenced_pat_vars": [ + "x" + ], + "referenced_action_vars": [], + "range": { + "start": 194428, + "end": 194452 + } + }, + { + "id": "effect_3", + "effect_id": "effect@194471:194525", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_vec_operand_get(t4, ctx.devalue(pat.i))", + "semantic_text": null, + "referenced_pat_vars": [ + "i" + ], + "referenced_action_vars": [ + "t4" + ], + "range": { + "start": 194471, + "end": 194525 + } + }, + { + "id": "effect_4", + "effect_id": "effect@194535:194552", + "bound_var": null, + "source_text": "ctx.union(t1, t3)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t1", + "t3" + ], + "range": { + "start": 194535, + "end": 194552 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0002", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "j", + "label": "j: ", + "plain_source": "j", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ j $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxVecOperand_get", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVO", + "plain_source": "upright(\"VO\")(x)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxVecOperand_length", + "plain_source": "upright(\"EcxVecOperand_length\")(upright(\"VO\")(x))", + "colored_source": "upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxVO", + "plain_source": "upright(\"VO\")(x)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $]" + } + ], + "side_conditions": [ + "j == upright(\"_t1.a1\")", + "i == j + 1", + "i < upright(\"_f3\")" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(i \\ j \\ upright(\"_t1\") \\ upright(\"VO\")(x) \\ upright(\"EcxVecOperand_length\")(upright(\"VO\")(x)) \\ upright(\"VO\")(x), upright(\"no conclusion\")) quad upright(\"if\") quad j == upright(\"_t1.a1\") \\ i == j + 1 \\ i < upright(\"_f3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ j $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $] \\ upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $], upright(\"no conclusion\")) quad upright(\"if\") quad j == upright(\"_t1.a1\") \\ i == j + 1 \\ i < upright(\"_f3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6627_5_MyTxEggccExtraction_add_rule__r0003__b8a0dfc7ecbcb067", + "display_name": "r0003", + "rule_name": "r0003", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 194566, + "line": 6627, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 194566, + "end": 194761 + }, + "pattern_range": { + "start": 194611, + "end": 194622 + }, + "action_range": { + "start": 194624, + "end": 194760 + } + }, + "nodes": [ + { + "id": "x", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "x: EcxVecOperandBase", + "range": { + "start": 20275, + "end": 20315 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t1: EcxVO", + "range": { + "start": 20320, + "end": 20347 + }, + "inputs": [ + "x" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "x", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "x", + "_t1" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@194654:194678", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_vo(pat.x)", + "semantic_text": null, + "referenced_pat_vars": [ + "x" + ], + "referenced_action_vars": [], + "range": { + "start": 194654, + "end": 194678 + } + }, + { + "id": "effect_1", + "effect_id": "effect@194688:194753", + "bound_var": null, + "source_text": "ctx.set_ecx_vec_operand_length(t1, vec_len(&*ctx.devalue(pat.x)))", + "semantic_text": "ecx_vec_operand_length(t1) = vec_len(*ctx.devalue(pat.x))", + "referenced_pat_vars": [ + "x" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 194688, + "end": 194753 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0003", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxVO", + "plain_source": "upright(\"VO\")(x)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "effect_1", + "plain_source": "upright(\"ecx_vec_operand_length\")(upright(\"EcxVo\")(x)) = upright(\"vec_len\")(*x)", + "colored_source": "upright(\"ecx_vec_operand_length\")(upright(\"EcxVo\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $])) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"vec_len\")(*x) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"VO\")(x), upright(\"ecx_vec_operand_length\")(upright(\"EcxVo\")(x)) = upright(\"vec_len\")(*x)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $], upright(\"ecx_vec_operand_length\")(upright(\"EcxVo\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $])) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"vec_len\")(*x) $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6631_5_MyTxEggccExtraction_add_rule__r0004__a89900621aaf3b6d", + "display_name": "r0004", + "rule_name": "r0004", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 194767, + "line": 6631, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 194767, + "end": 195087 + }, + "pattern_range": { + "start": 194812, + "end": 194823 + }, + "action_range": { + "start": 194825, + "end": 195086 + } + }, + "nodes": [ + { + "id": "x", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperandBase", + "label": "x: EcxVecVecOperandBase", + "range": { + "start": 20563, + "end": 20606 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t1: EcxVVO", + "range": { + "start": 20611, + "end": 20639 + }, + "inputs": [ + "x" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t3: EcxVVO", + "range": { + "start": 20644, + "end": 20672 + }, + "inputs": [ + "x" + ] + }, + { + "id": "_f2", + "kind": "query", + "dsl_type": "EcxVecVecOperand_length", + "label": "_f2: EcxVecVecOperand_length", + "range": { + "start": 20677, + "end": 20724 + }, + "inputs": [ + "_t3" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "x", + "kind": "operand", + "index": 0 + }, + { + "from": "_t3", + "to": "x", + "kind": "operand", + "index": 0 + }, + { + "from": "_f2", + "to": "_t3", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "x", + "_t1", + "_f2", + "_t3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "_f2.handle().gt(&(&(0_i64)).as_handle())", + "semantic_text": "_f2 > 0", + "referenced_vars": [ + "_f2" + ], + "range": { + "start": 20822, + "end": 20824 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@194855:194880", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_vvo(pat.x)", + "semantic_text": null, + "referenced_pat_vars": [ + "x" + ], + "referenced_action_vars": [], + "range": { + "start": 194855, + "end": 194880 + } + }, + { + "id": "effect_1", + "effect_id": "effect@194899:194944", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_vec_vec_operand_get(t2, 0_i64)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 194899, + "end": 194944 + } + }, + { + "id": "effect_2", + "effect_id": "effect@194963:194988", + "bound_var": "t4", + "source_text": "ctx.insert_ecx_vvo(pat.x)", + "semantic_text": null, + "referenced_pat_vars": [ + "x" + ], + "referenced_action_vars": [], + "range": { + "start": 194963, + "end": 194988 + } + }, + { + "id": "effect_3", + "effect_id": "effect@195007:195052", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_vec_vec_operand_get(t4, 0_i64)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t4" + ], + "range": { + "start": 195007, + "end": 195052 + } + }, + { + "id": "effect_4", + "effect_id": "effect@195062:195079", + "bound_var": null, + "source_text": "ctx.union(t1, t3)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t1", + "t3" + ], + "range": { + "start": 195062, + "end": 195079 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0004", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxVVO", + "plain_source": "upright(\"VVO\")(x)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $]" + }, + { + "target_id": "_f2", + "label": "_f2: EcxVecVecOperand_length", + "plain_source": "upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(x))", + "colored_source": "upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $])" + }, + { + "target_id": "_t3", + "label": "_t3: EcxVVO", + "plain_source": "upright(\"VVO\")(x)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $]" + } + ], + "side_conditions": [ + "upright(\"_f2\") > 0" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"VVO\")(x) \\ upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(x)) \\ upright(\"VVO\")(x), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"_f2\") > 0", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $] \\ upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"_f2\") > 0" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6638_5_MyTxEggccExtraction_add_rule__r0005__a22a76d404e3edfd", + "display_name": "r0005", + "rule_name": "r0005", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 195093, + "line": 6638, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 195093, + "end": 195439 + }, + "pattern_range": { + "start": 195138, + "end": 195149 + }, + "action_range": { + "start": 195151, + "end": 195438 + } + }, + "nodes": [ + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 21071, + "end": 21116 + }, + "inputs": [] + }, + { + "id": "j", + "kind": "query", + "dsl_type": "", + "label": "j: ", + "range": { + "start": 21121, + "end": 21166 + }, + "inputs": [] + }, + { + "id": "x", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperandBase", + "label": "x: EcxVecVecOperandBase", + "range": { + "start": 21171, + "end": 21214 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t2: EcxVVO", + "range": { + "start": 21219, + "end": 21247 + }, + "inputs": [ + "x" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxVecVecOperand_get", + "label": "_t1: EcxVecVecOperand_get", + "range": { + "start": 21252, + "end": 21296 + }, + "inputs": [ + "_t2" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t4: EcxVVO", + "range": { + "start": 21301, + "end": 21329 + }, + "inputs": [ + "x" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxVecVecOperand_length", + "label": "_f3: EcxVecVecOperand_length", + "range": { + "start": 21334, + "end": 21381 + }, + "inputs": [ + "_t4" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "x", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "x", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "_t4", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "i", + "j", + "x", + "_t1", + "_t2", + "_f3", + "_t4" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "j.handle().eq(&_t1.handle_a1())", + "semantic_text": "j == _t1.a1", + "referenced_vars": [ + "_t1", + "j" + ], + "range": { + "start": 21601, + "end": 21603 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "i.handle().eq(&(j.handle() + (&(1_i64)).as_handle()))", + "semantic_text": "i == j + 1", + "referenced_vars": [ + "i", + "j" + ], + "range": { + "start": 21621, + "end": 21623 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "i.handle().lt(&_f3.handle())", + "semantic_text": "i < _f3", + "referenced_vars": [ + "_f3", + "i" + ], + "range": { + "start": 21641, + "end": 21643 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@195181:195206", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_vvo(pat.x)", + "semantic_text": null, + "referenced_pat_vars": [ + "x" + ], + "referenced_action_vars": [], + "range": { + "start": 195181, + "end": 195206 + } + }, + { + "id": "effect_1", + "effect_id": "effect@195225:195283", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_vec_vec_operand_get(t2, ctx.devalue(pat.i))", + "semantic_text": null, + "referenced_pat_vars": [ + "i" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 195225, + "end": 195283 + } + }, + { + "id": "effect_2", + "effect_id": "effect@195302:195327", + "bound_var": "t4", + "source_text": "ctx.insert_ecx_vvo(pat.x)", + "semantic_text": null, + "referenced_pat_vars": [ + "x" + ], + "referenced_action_vars": [], + "range": { + "start": 195302, + "end": 195327 + } + }, + { + "id": "effect_3", + "effect_id": "effect@195346:195404", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_vec_vec_operand_get(t4, ctx.devalue(pat.i))", + "semantic_text": null, + "referenced_pat_vars": [ + "i" + ], + "referenced_action_vars": [ + "t4" + ], + "range": { + "start": 195346, + "end": 195404 + } + }, + { + "id": "effect_4", + "effect_id": "effect@195414:195431", + "bound_var": null, + "source_text": "ctx.union(t1, t3)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t1", + "t3" + ], + "range": { + "start": 195414, + "end": 195431 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0005", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "j", + "label": "j: ", + "plain_source": "j", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ j $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxVecVecOperand_get", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVVO", + "plain_source": "upright(\"VVO\")(x)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxVecVecOperand_length", + "plain_source": "upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(x))", + "colored_source": "upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxVVO", + "plain_source": "upright(\"VVO\")(x)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $]" + } + ], + "side_conditions": [ + "j == upright(\"_t1.a1\")", + "i == j + 1", + "i < upright(\"_f3\")" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(i \\ j \\ upright(\"_t1\") \\ upright(\"VVO\")(x) \\ upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(x)) \\ upright(\"VVO\")(x), upright(\"no conclusion\")) quad upright(\"if\") quad j == upright(\"_t1.a1\") \\ i == j + 1 \\ i < upright(\"_f3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ j $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $] \\ upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $], upright(\"no conclusion\")) quad upright(\"if\") quad j == upright(\"_t1.a1\") \\ i == j + 1 \\ i < upright(\"_f3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6645_5_MyTxEggccExtraction_add_rule__r0006__ded6830caaf4e6d0", + "display_name": "r0006", + "rule_name": "r0006", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 195445, + "line": 6645, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 195445, + "end": 195645 + }, + "pattern_range": { + "start": 195490, + "end": 195501 + }, + "action_range": { + "start": 195503, + "end": 195644 + } + }, + "nodes": [ + { + "id": "x", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperandBase", + "label": "x: EcxVecVecOperandBase", + "range": { + "start": 21804, + "end": 21847 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t1: EcxVVO", + "range": { + "start": 21852, + "end": 21880 + }, + "inputs": [ + "x" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "x", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "x", + "_t1" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@195533:195558", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_vvo(pat.x)", + "semantic_text": null, + "referenced_pat_vars": [ + "x" + ], + "referenced_action_vars": [], + "range": { + "start": 195533, + "end": 195558 + } + }, + { + "id": "effect_1", + "effect_id": "effect@195568:195637", + "bound_var": null, + "source_text": "ctx.set_ecx_vec_vec_operand_length(t1, vec_len(&*ctx.devalue(pat.x)))", + "semantic_text": "ecx_vec_vec_operand_length(t1) = vec_len(*ctx.devalue(pat.x))", + "referenced_pat_vars": [ + "x" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 195568, + "end": 195637 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0006", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxVVO", + "plain_source": "upright(\"VVO\")(x)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "effect_1", + "plain_source": "upright(\"ecx_vec_vec_operand_length\")(upright(\"EcxVvo\")(x)) = upright(\"vec_len\")(*x)", + "colored_source": "upright(\"ecx_vec_vec_operand_length\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $])) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"vec_len\")(*x) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"VVO\")(x), upright(\"ecx_vec_vec_operand_length\")(upright(\"EcxVvo\")(x)) = upright(\"vec_len\")(*x)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $], upright(\"ecx_vec_vec_operand_length\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $])) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"vec_len\")(*x) $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6649_5_MyTxEggccExtraction_add_rule__r0007__b6892b9604e7279f", + "display_name": "r0007", + "rule_name": "r0007", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 195651, + "line": 6649, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 195651, + "end": 195783 + }, + "pattern_range": { + "start": 195696, + "end": 195707 + }, + "action_range": { + "start": 195709, + "end": 195782 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "f: EcxExpr", + "range": { + "start": 22114, + "end": 22144 + }, + "inputs": [] + }, + { + "id": "lit", + "kind": "query_leaf", + "dsl_type": "EcxLiteral", + "label": "lit: EcxLiteral", + "range": { + "start": 22149, + "end": 22184 + }, + "inputs": [] + }, + { + "id": "ops", + "kind": "query_leaf", + "dsl_type": "EcxConstOps", + "label": "ops: EcxConstOps", + "range": { + "start": 22189, + "end": 22225 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty: EcxType", + "range": { + "start": 22230, + "end": 22261 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxConst", + "label": "_t1: EcxConst", + "range": { + "start": 22266, + "end": 22309 + }, + "inputs": [ + "ty", + "ops", + "lit" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "ops", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "lit", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "f", + "lit", + "ops", + "ty", + "_t1" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 22399, + "end": 22401 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@195741:195775", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_expr_is_pure(pat.f)", + "semantic_text": null, + "referenced_pat_vars": [ + "f" + ], + "referenced_action_vars": [], + "range": { + "start": 195741, + "end": 195775 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0007", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxConst", + "plain_source": "upright(\"Const\")(upright(\"ty\"), upright(\"ops\"), upright(\"lit\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lit\") $]) $]" + } + ], + "side_conditions": [ + "f == upright(\"_t1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxExprIsPure\")(f)", + "colored_source": "upright(\"EcxExprIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxExprIsPure\")(f)", + "colored_source": "upright(\"EcxExprIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"Const\")(upright(\"ty\"), upright(\"ops\"), upright(\"lit\")), upright(\"EcxExprIsPure\")(f)) quad upright(\"if\") quad f == upright(\"_t1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lit\") $]) $], upright(\"EcxExprIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])) quad upright(\"if\") quad f == upright(\"_t1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6652_5_MyTxEggccExtraction_add_rule__r0008__b1e7ea462ac69a32", + "display_name": "r0008", + "rule_name": "r0008", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 195789, + "line": 6652, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 195789, + "end": 195921 + }, + "pattern_range": { + "start": 195834, + "end": 195845 + }, + "action_range": { + "start": 195847, + "end": 195920 + } + }, + "nodes": [ + { + "id": "args", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "args: EcxVecOperand", + "range": { + "start": 22769, + "end": 22808 + }, + "inputs": [] + }, + { + "id": "body", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "body: EcxVecOperand", + "range": { + "start": 22813, + "end": 22852 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "f: EcxExpr", + "range": { + "start": 22857, + "end": 22887 + }, + "inputs": [] + }, + { + "id": "input_types", + "kind": "query_leaf", + "dsl_type": "EcxFuncSigs", + "label": "input_types: EcxFuncSigs", + "range": { + "start": 22892, + "end": 22936 + }, + "inputs": [] + }, + { + "id": "n_outs", + "kind": "query", + "dsl_type": "", + "label": "n_outs: ", + "range": { + "start": 22941, + "end": 22996 + }, + "inputs": [] + }, + { + "id": "name", + "kind": "query", + "dsl_type": "", + "label": "name: ", + "range": { + "start": 23001, + "end": 23055 + }, + "inputs": [] + }, + { + "id": "output_types", + "kind": "query_leaf", + "dsl_type": "EcxFuncSigs", + "label": "output_types: EcxFuncSigs", + "range": { + "start": 23060, + "end": 23105 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxOptionType", + "label": "ty: EcxOptionType", + "range": { + "start": 23110, + "end": 23147 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxCall", + "label": "_t1: EcxCall", + "range": { + "start": 23152, + "end": 23189 + }, + "inputs": [ + "ty", + "args" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxFunc", + "label": "_t3: EcxFunc", + "range": { + "start": 23194, + "end": 23255 + }, + "inputs": [ + "input_types", + "output_types", + "body" + ] + }, + { + "id": "_rel2", + "kind": "query", + "dsl_type": "EcxFunction_is_pure", + "label": "_rel2: EcxFunction_is_pure", + "range": { + "start": 23260, + "end": 23305 + }, + "inputs": [ + "_t3" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "args", + "kind": "operand", + "index": 1 + }, + { + "from": "_t3", + "to": "input_types", + "kind": "operand", + "index": 0 + }, + { + "from": "_t3", + "to": "output_types", + "kind": "operand", + "index": 1 + }, + { + "from": "_t3", + "to": "body", + "kind": "operand", + "index": 2 + }, + { + "from": "_rel2", + "to": "_t3", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "args", + "body", + "f", + "input_types", + "n_outs", + "name", + "output_types", + "ty", + "_t1", + "_rel2", + "_t3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "name.handle().eq(&_t1.handle_a1())", + "semantic_text": "name == _t1.a1", + "referenced_vars": [ + "_t1", + "name" + ], + "range": { + "start": 23699, + "end": 23701 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "n_outs.handle().eq(&_t1.handle_a3())", + "semantic_text": "n_outs == _t1.a3", + "referenced_vars": [ + "_t1", + "n_outs" + ], + "range": { + "start": 23715, + "end": 23717 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 23731, + "end": 23733 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "name.handle().eq(&_t3.handle_a0())", + "semantic_text": "name == _t3.a0", + "referenced_vars": [ + "_t3", + "name" + ], + "range": { + "start": 23747, + "end": 23749 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@195879:195913", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_expr_is_pure(pat.f)", + "semantic_text": null, + "referenced_pat_vars": [ + "f" + ], + "referenced_action_vars": [], + "range": { + "start": 195879, + "end": 195913 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0008", + "premises": [ + { + "target_id": "n_outs", + "label": "n_outs: ", + "plain_source": "upright(\"n_outs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"n_outs\") $]" + }, + { + "target_id": "name", + "label": "name: ", + "plain_source": "upright(\"name\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"name\") $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxCall", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_rel2", + "label": "_rel2: EcxFunction_is_pure", + "plain_source": "upright(\"Function_is_pure\")(upright(\"_t3\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Function_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxFunc", + "plain_source": "upright(\"_t3\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]" + } + ], + "side_conditions": [ + "upright(\"name\") == upright(\"_t1.a1\")", + "upright(\"n_outs\") == upright(\"_t1.a3\")", + "f == upright(\"_t1\")", + "upright(\"name\") == upright(\"_t3.a0\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxExprIsPure\")(f)", + "colored_source": "upright(\"EcxExprIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxExprIsPure\")(f)", + "colored_source": "upright(\"EcxExprIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"n_outs\") \\ upright(\"name\") \\ upright(\"_t1\") \\ upright(\"Function_is_pure\")(upright(\"_t3\")) \\ upright(\"_t3\"), upright(\"EcxExprIsPure\")(f)) quad upright(\"if\") quad upright(\"name\") == upright(\"_t1.a1\") \\ upright(\"n_outs\") == upright(\"_t1.a3\") \\ f == upright(\"_t1\") \\ upright(\"name\") == upright(\"_t3.a0\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"n_outs\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"name\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Function_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $], upright(\"EcxExprIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])) quad upright(\"if\") quad upright(\"name\") == upright(\"_t1.a1\") \\ upright(\"n_outs\") == upright(\"_t1.a3\") \\ f == upright(\"_t1\") \\ upright(\"name\") == upright(\"_t3.a0\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6655_5_MyTxEggccExtraction_add_rule__r0009__4bc89ed711348ca4", + "display_name": "r0009", + "rule_name": "r0009", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 195927, + "line": 6655, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 195927, + "end": 196059 + }, + "pattern_range": { + "start": 195972, + "end": 195983 + }, + "action_range": { + "start": 195985, + "end": 196058 + } + }, + "nodes": [ + { + "id": "e1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e1: EcxOperand", + "range": { + "start": 24022, + "end": 24056 + }, + "inputs": [] + }, + { + "id": "e2", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e2: EcxOperand", + "range": { + "start": 24061, + "end": 24095 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "f: EcxExpr", + "range": { + "start": 24100, + "end": 24130 + }, + "inputs": [] + }, + { + "id": "kw_type", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "kw_type: EcxType", + "range": { + "start": 24135, + "end": 24171 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "Ecxbadd", + "label": "_t1: Ecxbadd", + "range": { + "start": 24176, + "end": 24221 + }, + "inputs": [ + "kw_type", + "e1", + "e2" + ] + }, + { + "id": "_rel2", + "kind": "query", + "dsl_type": "EcxOperand_is_pure", + "label": "_rel2: EcxOperand_is_pure", + "range": { + "start": 24226, + "end": 24269 + }, + "inputs": [ + "e1" + ] + }, + { + "id": "_rel3", + "kind": "query", + "dsl_type": "EcxOperand_is_pure", + "label": "_rel3: EcxOperand_is_pure", + "range": { + "start": 24274, + "end": 24317 + }, + "inputs": [ + "e2" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "kw_type", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "e1", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "e2", + "kind": "operand", + "index": 2 + }, + { + "from": "_rel2", + "to": "e1", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel3", + "to": "e2", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "e1", + "e2", + "f", + "kw_type", + "_t1", + "_rel2", + "_rel3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 24424, + "end": 24426 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@196017:196051", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_expr_is_pure(pat.f)", + "semantic_text": null, + "referenced_pat_vars": [ + "f" + ], + "referenced_action_vars": [], + "range": { + "start": 196017, + "end": 196051 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0009", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: Ecxbadd", + "plain_source": "upright(\"badd\")(upright(\"kw_type\"), e_1, e_2)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $]" + }, + { + "target_id": "_rel2", + "label": "_rel2: EcxOperand_is_pure", + "plain_source": "upright(\"Operand_is_pure\")(e_1)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Operand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ e_1 $]) $]" + }, + { + "target_id": "_rel3", + "label": "_rel3: EcxOperand_is_pure", + "plain_source": "upright(\"Operand_is_pure\")(e_2)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Operand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $]" + } + ], + "side_conditions": [ + "f == upright(\"_t1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxExprIsPure\")(f)", + "colored_source": "upright(\"EcxExprIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxExprIsPure\")(f)", + "colored_source": "upright(\"EcxExprIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"badd\")(upright(\"kw_type\"), e_1, e_2) \\ upright(\"Operand_is_pure\")(e_1) \\ upright(\"Operand_is_pure\")(e_2), upright(\"EcxExprIsPure\")(f)) quad upright(\"if\") quad f == upright(\"_t1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Operand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ e_1 $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Operand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $], upright(\"EcxExprIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])) quad upright(\"if\") quad f == upright(\"_t1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6658_5_MyTxEggccExtraction_add_rule__r0010__5c2c7afb66199961", + "display_name": "r0010", + "rule_name": "r0010", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 196065, + "line": 6658, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 196065, + "end": 196197 + }, + "pattern_range": { + "start": 196110, + "end": 196121 + }, + "action_range": { + "start": 196123, + "end": 196196 + } + }, + "nodes": [ + { + "id": "e1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e1: EcxOperand", + "range": { + "start": 24699, + "end": 24733 + }, + "inputs": [] + }, + { + "id": "e2", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e2: EcxOperand", + "range": { + "start": 24738, + "end": 24772 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "f: EcxExpr", + "range": { + "start": 24777, + "end": 24807 + }, + "inputs": [] + }, + { + "id": "kw_type", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "kw_type: EcxType", + "range": { + "start": 24812, + "end": 24848 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "Ecxbsub", + "label": "_t1: Ecxbsub", + "range": { + "start": 24853, + "end": 24898 + }, + "inputs": [ + "kw_type", + "e1", + "e2" + ] + }, + { + "id": "_rel2", + "kind": "query", + "dsl_type": "EcxOperand_is_pure", + "label": "_rel2: EcxOperand_is_pure", + "range": { + "start": 24903, + "end": 24946 + }, + "inputs": [ + "e1" + ] + }, + { + "id": "_rel3", + "kind": "query", + "dsl_type": "EcxOperand_is_pure", + "label": "_rel3: EcxOperand_is_pure", + "range": { + "start": 24951, + "end": 24994 + }, + "inputs": [ + "e2" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "kw_type", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "e1", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "e2", + "kind": "operand", + "index": 2 + }, + { + "from": "_rel2", + "to": "e1", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel3", + "to": "e2", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "e1", + "e2", + "f", + "kw_type", + "_t1", + "_rel2", + "_rel3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 25101, + "end": 25103 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@196155:196189", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_expr_is_pure(pat.f)", + "semantic_text": null, + "referenced_pat_vars": [ + "f" + ], + "referenced_action_vars": [], + "range": { + "start": 196155, + "end": 196189 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0010", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: Ecxbsub", + "plain_source": "upright(\"bsub\")(upright(\"kw_type\"), e_1, e_2)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $]" + }, + { + "target_id": "_rel2", + "label": "_rel2: EcxOperand_is_pure", + "plain_source": "upright(\"Operand_is_pure\")(e_1)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Operand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ e_1 $]) $]" + }, + { + "target_id": "_rel3", + "label": "_rel3: EcxOperand_is_pure", + "plain_source": "upright(\"Operand_is_pure\")(e_2)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Operand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $]" + } + ], + "side_conditions": [ + "f == upright(\"_t1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxExprIsPure\")(f)", + "colored_source": "upright(\"EcxExprIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxExprIsPure\")(f)", + "colored_source": "upright(\"EcxExprIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"bsub\")(upright(\"kw_type\"), e_1, e_2) \\ upright(\"Operand_is_pure\")(e_1) \\ upright(\"Operand_is_pure\")(e_2), upright(\"EcxExprIsPure\")(f)) quad upright(\"if\") quad f == upright(\"_t1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Operand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ e_1 $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Operand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $], upright(\"EcxExprIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])) quad upright(\"if\") quad f == upright(\"_t1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6661_5_MyTxEggccExtraction_add_rule__r0011__157cc21ad55cb9fe", + "display_name": "r0011", + "rule_name": "r0011", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 196203, + "line": 6661, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 196203, + "end": 196335 + }, + "pattern_range": { + "start": 196248, + "end": 196259 + }, + "action_range": { + "start": 196261, + "end": 196334 + } + }, + "nodes": [ + { + "id": "e1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e1: EcxOperand", + "range": { + "start": 25376, + "end": 25410 + }, + "inputs": [] + }, + { + "id": "e2", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e2: EcxOperand", + "range": { + "start": 25415, + "end": 25449 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "f: EcxExpr", + "range": { + "start": 25454, + "end": 25484 + }, + "inputs": [] + }, + { + "id": "kw_type", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "kw_type: EcxType", + "range": { + "start": 25489, + "end": 25525 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "Ecxbmul", + "label": "_t1: Ecxbmul", + "range": { + "start": 25530, + "end": 25575 + }, + "inputs": [ + "kw_type", + "e1", + "e2" + ] + }, + { + "id": "_rel2", + "kind": "query", + "dsl_type": "EcxOperand_is_pure", + "label": "_rel2: EcxOperand_is_pure", + "range": { + "start": 25580, + "end": 25623 + }, + "inputs": [ + "e1" + ] + }, + { + "id": "_rel3", + "kind": "query", + "dsl_type": "EcxOperand_is_pure", + "label": "_rel3: EcxOperand_is_pure", + "range": { + "start": 25628, + "end": 25671 + }, + "inputs": [ + "e2" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "kw_type", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "e1", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "e2", + "kind": "operand", + "index": 2 + }, + { + "from": "_rel2", + "to": "e1", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel3", + "to": "e2", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "e1", + "e2", + "f", + "kw_type", + "_t1", + "_rel2", + "_rel3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 25778, + "end": 25780 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@196293:196327", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_expr_is_pure(pat.f)", + "semantic_text": null, + "referenced_pat_vars": [ + "f" + ], + "referenced_action_vars": [], + "range": { + "start": 196293, + "end": 196327 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0011", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: Ecxbmul", + "plain_source": "upright(\"bmul\")(upright(\"kw_type\"), e_1, e_2)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $]" + }, + { + "target_id": "_rel2", + "label": "_rel2: EcxOperand_is_pure", + "plain_source": "upright(\"Operand_is_pure\")(e_1)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Operand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ e_1 $]) $]" + }, + { + "target_id": "_rel3", + "label": "_rel3: EcxOperand_is_pure", + "plain_source": "upright(\"Operand_is_pure\")(e_2)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Operand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $]" + } + ], + "side_conditions": [ + "f == upright(\"_t1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxExprIsPure\")(f)", + "colored_source": "upright(\"EcxExprIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxExprIsPure\")(f)", + "colored_source": "upright(\"EcxExprIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"bmul\")(upright(\"kw_type\"), e_1, e_2) \\ upright(\"Operand_is_pure\")(e_1) \\ upright(\"Operand_is_pure\")(e_2), upright(\"EcxExprIsPure\")(f)) quad upright(\"if\") quad f == upright(\"_t1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Operand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ e_1 $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Operand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $], upright(\"EcxExprIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])) quad upright(\"if\") quad f == upright(\"_t1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6664_5_MyTxEggccExtraction_add_rule__r0012__7afb49bbe52816a8", + "display_name": "r0012", + "rule_name": "r0012", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 196341, + "line": 6664, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 196341, + "end": 196473 + }, + "pattern_range": { + "start": 196386, + "end": 196397 + }, + "action_range": { + "start": 196399, + "end": 196472 + } + }, + "nodes": [ + { + "id": "e1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e1: EcxOperand", + "range": { + "start": 26053, + "end": 26087 + }, + "inputs": [] + }, + { + "id": "e2", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e2: EcxOperand", + "range": { + "start": 26092, + "end": 26126 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "f: EcxExpr", + "range": { + "start": 26131, + "end": 26161 + }, + "inputs": [] + }, + { + "id": "kw_type", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "kw_type: EcxType", + "range": { + "start": 26166, + "end": 26202 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "Ecxbdiv", + "label": "_t1: Ecxbdiv", + "range": { + "start": 26207, + "end": 26252 + }, + "inputs": [ + "kw_type", + "e1", + "e2" + ] + }, + { + "id": "_rel2", + "kind": "query", + "dsl_type": "EcxOperand_is_pure", + "label": "_rel2: EcxOperand_is_pure", + "range": { + "start": 26257, + "end": 26300 + }, + "inputs": [ + "e1" + ] + }, + { + "id": "_rel3", + "kind": "query", + "dsl_type": "EcxOperand_is_pure", + "label": "_rel3: EcxOperand_is_pure", + "range": { + "start": 26305, + "end": 26348 + }, + "inputs": [ + "e2" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "kw_type", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "e1", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "e2", + "kind": "operand", + "index": 2 + }, + { + "from": "_rel2", + "to": "e1", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel3", + "to": "e2", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "e1", + "e2", + "f", + "kw_type", + "_t1", + "_rel2", + "_rel3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 26455, + "end": 26457 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@196431:196465", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_expr_is_pure(pat.f)", + "semantic_text": null, + "referenced_pat_vars": [ + "f" + ], + "referenced_action_vars": [], + "range": { + "start": 196431, + "end": 196465 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0012", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: Ecxbdiv", + "plain_source": "upright(\"bdiv\")(upright(\"kw_type\"), e_1, e_2)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $]" + }, + { + "target_id": "_rel2", + "label": "_rel2: EcxOperand_is_pure", + "plain_source": "upright(\"Operand_is_pure\")(e_1)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Operand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ e_1 $]) $]" + }, + { + "target_id": "_rel3", + "label": "_rel3: EcxOperand_is_pure", + "plain_source": "upright(\"Operand_is_pure\")(e_2)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Operand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $]" + } + ], + "side_conditions": [ + "f == upright(\"_t1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxExprIsPure\")(f)", + "colored_source": "upright(\"EcxExprIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxExprIsPure\")(f)", + "colored_source": "upright(\"EcxExprIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"bdiv\")(upright(\"kw_type\"), e_1, e_2) \\ upright(\"Operand_is_pure\")(e_1) \\ upright(\"Operand_is_pure\")(e_2), upright(\"EcxExprIsPure\")(f)) quad upright(\"if\") quad f == upright(\"_t1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Operand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ e_1 $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Operand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $], upright(\"EcxExprIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])) quad upright(\"if\") quad f == upright(\"_t1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6667_5_MyTxEggccExtraction_add_rule__r0013__3c68bd63c3b6b96a", + "display_name": "r0013", + "rule_name": "r0013", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 196479, + "line": 6667, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 196479, + "end": 196611 + }, + "pattern_range": { + "start": 196524, + "end": 196535 + }, + "action_range": { + "start": 196537, + "end": 196610 + } + }, + "nodes": [ + { + "id": "e1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e1: EcxOperand", + "range": { + "start": 26729, + "end": 26763 + }, + "inputs": [] + }, + { + "id": "e2", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e2: EcxOperand", + "range": { + "start": 26768, + "end": 26802 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "f: EcxExpr", + "range": { + "start": 26807, + "end": 26837 + }, + "inputs": [] + }, + { + "id": "kw_type", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "kw_type: EcxType", + "range": { + "start": 26842, + "end": 26878 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "Ecxblt", + "label": "_t1: Ecxblt", + "range": { + "start": 26883, + "end": 26927 + }, + "inputs": [ + "kw_type", + "e1", + "e2" + ] + }, + { + "id": "_rel2", + "kind": "query", + "dsl_type": "EcxOperand_is_pure", + "label": "_rel2: EcxOperand_is_pure", + "range": { + "start": 26932, + "end": 26975 + }, + "inputs": [ + "e1" + ] + }, + { + "id": "_rel3", + "kind": "query", + "dsl_type": "EcxOperand_is_pure", + "label": "_rel3: EcxOperand_is_pure", + "range": { + "start": 26980, + "end": 27023 + }, + "inputs": [ + "e2" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "kw_type", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "e1", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "e2", + "kind": "operand", + "index": 2 + }, + { + "from": "_rel2", + "to": "e1", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel3", + "to": "e2", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "e1", + "e2", + "f", + "kw_type", + "_t1", + "_rel2", + "_rel3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 27130, + "end": 27132 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@196569:196603", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_expr_is_pure(pat.f)", + "semantic_text": null, + "referenced_pat_vars": [ + "f" + ], + "referenced_action_vars": [], + "range": { + "start": 196569, + "end": 196603 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0013", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: Ecxblt", + "plain_source": "upright(\"blt\")(upright(\"kw_type\"), e_1, e_2)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $]" + }, + { + "target_id": "_rel2", + "label": "_rel2: EcxOperand_is_pure", + "plain_source": "upright(\"Operand_is_pure\")(e_1)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Operand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ e_1 $]) $]" + }, + { + "target_id": "_rel3", + "label": "_rel3: EcxOperand_is_pure", + "plain_source": "upright(\"Operand_is_pure\")(e_2)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Operand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $]" + } + ], + "side_conditions": [ + "f == upright(\"_t1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxExprIsPure\")(f)", + "colored_source": "upright(\"EcxExprIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxExprIsPure\")(f)", + "colored_source": "upright(\"EcxExprIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"blt\")(upright(\"kw_type\"), e_1, e_2) \\ upright(\"Operand_is_pure\")(e_1) \\ upright(\"Operand_is_pure\")(e_2), upright(\"EcxExprIsPure\")(f)) quad upright(\"if\") quad f == upright(\"_t1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Operand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ e_1 $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Operand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $], upright(\"EcxExprIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])) quad upright(\"if\") quad f == upright(\"_t1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6670_5_MyTxEggccExtraction_add_rule__r0014__7f627b9d082c8287", + "display_name": "r0014", + "rule_name": "r0014", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 196617, + "line": 6670, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 196617, + "end": 196752 + }, + "pattern_range": { + "start": 196662, + "end": 196673 + }, + "action_range": { + "start": 196675, + "end": 196751 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "f: EcxOperand", + "range": { + "start": 27295, + "end": 27328 + }, + "inputs": [] + }, + { + "id": "x", + "kind": "query", + "dsl_type": "", + "label": "x: ", + "range": { + "start": 27333, + "end": 27378 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxArg", + "label": "_t1: EcxArg", + "range": { + "start": 27383, + "end": 27409 + }, + "inputs": [] + } + ], + "edges": [], + "roots": [ + "f", + "x", + "_t1" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x.handle().eq(&_t1.handle_a0())", + "semantic_text": "x == _t1.a0", + "referenced_vars": [ + "_t1", + "x" + ], + "range": { + "start": 27534, + "end": 27536 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 27545, + "end": 27547 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@196707:196744", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_operand_is_pure(pat.f)", + "semantic_text": null, + "referenced_pat_vars": [ + "f" + ], + "referenced_action_vars": [], + "range": { + "start": 196707, + "end": 196744 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0014", + "premises": [ + { + "target_id": "x", + "label": "x: ", + "plain_source": "x", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxArg", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + } + ], + "side_conditions": [ + "x == upright(\"_t1.a0\")", + "f == upright(\"_t1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxOperandIsPure\")(f)", + "colored_source": "upright(\"EcxOperandIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxOperandIsPure\")(f)", + "colored_source": "upright(\"EcxOperandIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + } + ], + "formula_source": { + "plain": "frac(x \\ upright(\"_t1\"), upright(\"EcxOperandIsPure\")(f)) quad upright(\"if\") quad x == upright(\"_t1.a0\") \\ f == upright(\"_t1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $], upright(\"EcxOperandIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])) quad upright(\"if\") quad x == upright(\"_t1.a0\") \\ f == upright(\"_t1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6673_5_MyTxEggccExtraction_add_rule__r0015__70d190ce546398e9", + "display_name": "r0015", + "rule_name": "r0015", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 196758, + "line": 6673, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 196758, + "end": 196893 + }, + "pattern_range": { + "start": 196803, + "end": 196814 + }, + "action_range": { + "start": 196816, + "end": 196892 + } + }, + "nodes": [ + { + "id": "body", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "body: EcxBody", + "range": { + "start": 27746, + "end": 27779 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "f: EcxOperand", + "range": { + "start": 27784, + "end": 27817 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t1: EcxNode", + "range": { + "start": 27822, + "end": 27854 + }, + "inputs": [ + "body" + ] + }, + { + "id": "_rel2", + "kind": "query", + "dsl_type": "EcxBody_is_pure", + "label": "_rel2: EcxBody_is_pure", + "range": { + "start": 27859, + "end": 27901 + }, + "inputs": [ + "body" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "body", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel2", + "to": "body", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "body", + "f", + "_t1", + "_rel2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 27990, + "end": 27992 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@196848:196885", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_operand_is_pure(pat.f)", + "semantic_text": null, + "referenced_pat_vars": [ + "f" + ], + "referenced_action_vars": [], + "range": { + "start": 196848, + "end": 196885 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0015", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxNode", + "plain_source": "upright(\"Node\")(upright(\"body\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $]) $]" + }, + { + "target_id": "_rel2", + "label": "_rel2: EcxBody_is_pure", + "plain_source": "upright(\"Body_is_pure\")(upright(\"body\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Body_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $]) $]" + } + ], + "side_conditions": [ + "f == upright(\"_t1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxOperandIsPure\")(f)", + "colored_source": "upright(\"EcxOperandIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxOperandIsPure\")(f)", + "colored_source": "upright(\"EcxOperandIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"Node\")(upright(\"body\")) \\ upright(\"Body_is_pure\")(upright(\"body\")), upright(\"EcxOperandIsPure\")(f)) quad upright(\"if\") quad f == upright(\"_t1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Body_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $]) $], upright(\"EcxOperandIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])) quad upright(\"if\") quad f == upright(\"_t1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6676_5_MyTxEggccExtraction_add_rule__r0016__ab0521c17e04e18b", + "display_name": "r0016", + "rule_name": "r0016", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 196899, + "line": 6676, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 196899, + "end": 197034 + }, + "pattern_range": { + "start": 196944, + "end": 196955 + }, + "action_range": { + "start": 196957, + "end": 197033 + } + }, + "nodes": [ + { + "id": "body", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "body: EcxBody", + "range": { + "start": 28206, + "end": 28239 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "f: EcxOperand", + "range": { + "start": 28244, + "end": 28277 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 28282, + "end": 28327 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxProject", + "label": "_t1: EcxProject", + "range": { + "start": 28332, + "end": 28367 + }, + "inputs": [ + "body" + ] + }, + { + "id": "_rel2", + "kind": "query", + "dsl_type": "EcxBody_is_pure", + "label": "_rel2: EcxBody_is_pure", + "range": { + "start": 28372, + "end": 28414 + }, + "inputs": [ + "body" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "body", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel2", + "to": "body", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "body", + "f", + "i", + "_t1", + "_rel2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_t1.handle_a0())", + "semantic_text": "i == _t1.a0", + "referenced_vars": [ + "_t1", + "i" + ], + "range": { + "start": 28552, + "end": 28554 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 28563, + "end": 28565 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@196989:197026", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_operand_is_pure(pat.f)", + "semantic_text": null, + "referenced_pat_vars": [ + "f" + ], + "referenced_action_vars": [], + "range": { + "start": 196989, + "end": 197026 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0016", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxProject", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_rel2", + "label": "_rel2: EcxBody_is_pure", + "plain_source": "upright(\"Body_is_pure\")(upright(\"body\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Body_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $]) $]" + } + ], + "side_conditions": [ + "i == upright(\"_t1.a0\")", + "f == upright(\"_t1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxOperandIsPure\")(f)", + "colored_source": "upright(\"EcxOperandIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxOperandIsPure\")(f)", + "colored_source": "upright(\"EcxOperandIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + } + ], + "formula_source": { + "plain": "frac(i \\ upright(\"_t1\") \\ upright(\"Body_is_pure\")(upright(\"body\")), upright(\"EcxOperandIsPure\")(f)) quad upright(\"if\") quad i == upright(\"_t1.a0\") \\ f == upright(\"_t1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Body_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $]) $], upright(\"EcxOperandIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])) quad upright(\"if\") quad i == upright(\"_t1.a0\") \\ f == upright(\"_t1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6679_5_MyTxEggccExtraction_add_rule__r0017__4ebf7ec845562639", + "display_name": "r0017", + "rule_name": "r0017", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 197040, + "line": 6679, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 197040, + "end": 197172 + }, + "pattern_range": { + "start": 197085, + "end": 197096 + }, + "action_range": { + "start": 197098, + "end": 197171 + } + }, + "nodes": [ + { + "id": "e", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "e: EcxExpr", + "range": { + "start": 28760, + "end": 28790 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "f: EcxBody", + "range": { + "start": 28795, + "end": 28825 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t1: EcxPureOp", + "range": { + "start": 28830, + "end": 28861 + }, + "inputs": [ + "e" + ] + }, + { + "id": "_rel2", + "kind": "query", + "dsl_type": "EcxExpr_is_pure", + "label": "_rel2: EcxExpr_is_pure", + "range": { + "start": 28866, + "end": 28905 + }, + "inputs": [ + "e" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "e", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel2", + "to": "e", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "e", + "f", + "_t1", + "_rel2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 28991, + "end": 28993 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@197130:197164", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_body_is_pure(pat.f)", + "semantic_text": null, + "referenced_pat_vars": [ + "f" + ], + "referenced_action_vars": [], + "range": { + "start": 197130, + "end": 197164 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0017", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxPureOp", + "plain_source": "upright(\"PureOp\")(e)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $]) $]" + }, + { + "target_id": "_rel2", + "label": "_rel2: EcxExpr_is_pure", + "plain_source": "upright(\"Expr_is_pure\")(e)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Expr_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $]) $]" + } + ], + "side_conditions": [ + "f == upright(\"_t1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyIsPure\")(f)", + "colored_source": "upright(\"EcxBodyIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyIsPure\")(f)", + "colored_source": "upright(\"EcxBodyIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PureOp\")(e) \\ upright(\"Expr_is_pure\")(e), upright(\"EcxBodyIsPure\")(f)) quad upright(\"if\") quad f == upright(\"_t1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Expr_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $]) $], upright(\"EcxBodyIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])) quad upright(\"if\") quad f == upright(\"_t1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6682_5_MyTxEggccExtraction_add_rule__r0018__e3ff72975e5818b2", + "display_name": "r0018", + "rule_name": "r0018", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 197178, + "line": 6682, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 197178, + "end": 197310 + }, + "pattern_range": { + "start": 197223, + "end": 197234 + }, + "action_range": { + "start": 197236, + "end": 197309 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "f: EcxBody", + "range": { + "start": 29325, + "end": 29355 + }, + "inputs": [] + }, + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 29360, + "end": 29401 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "outputs: EcxVecVecOperand", + "range": { + "start": 29406, + "end": 29451 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 29456, + "end": 29492 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxGamma", + "label": "_t1: EcxGamma", + "range": { + "start": 29497, + "end": 29549 + }, + "inputs": [ + "pred", + "inputs", + "outputs" + ] + }, + { + "id": "_rel2", + "kind": "query", + "dsl_type": "EcxOperand_is_pure", + "label": "_rel2: EcxOperand_is_pure", + "range": { + "start": 29554, + "end": 29599 + }, + "inputs": [ + "pred" + ] + }, + { + "id": "_rel3", + "kind": "query", + "dsl_type": "EcxVecOperand_is_pure", + "label": "_rel3: EcxVecOperand_is_pure", + "range": { + "start": 29604, + "end": 29654 + }, + "inputs": [ + "inputs" + ] + }, + { + "id": "_rel4", + "kind": "query", + "dsl_type": "EcxVecVecOperand_is_pure", + "label": "_rel4: EcxVecVecOperand_is_pure", + "range": { + "start": 29659, + "end": 29713 + }, + "inputs": [ + "outputs" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "outputs", + "kind": "operand", + "index": 2 + }, + { + "from": "_rel2", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel3", + "to": "inputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel4", + "to": "outputs", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "f", + "inputs", + "outputs", + "pred", + "_t1", + "_rel2", + "_rel3", + "_rel4" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 29833, + "end": 29835 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@197268:197302", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_body_is_pure(pat.f)", + "semantic_text": null, + "referenced_pat_vars": [ + "f" + ], + "referenced_action_vars": [], + "range": { + "start": 197268, + "end": 197302 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0018", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxGamma", + "plain_source": "upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "_rel2", + "label": "_rel2: EcxOperand_is_pure", + "plain_source": "upright(\"Operand_is_pure\")(upright(\"pred\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Operand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $]) $]" + }, + { + "target_id": "_rel3", + "label": "_rel3: EcxVecOperand_is_pure", + "plain_source": "upright(\"VecOperand_is_pure\")(upright(\"inputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VecOperand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $]" + }, + { + "target_id": "_rel4", + "label": "_rel4: EcxVecVecOperand_is_pure", + "plain_source": "upright(\"VecVecOperand_is_pure\")(upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VecVecOperand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + ], + "side_conditions": [ + "f == upright(\"_t1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyIsPure\")(f)", + "colored_source": "upright(\"EcxBodyIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyIsPure\")(f)", + "colored_source": "upright(\"EcxBodyIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\")) \\ upright(\"Operand_is_pure\")(upright(\"pred\")) \\ upright(\"VecOperand_is_pure\")(upright(\"inputs\")) \\ upright(\"VecVecOperand_is_pure\")(upright(\"outputs\")), upright(\"EcxBodyIsPure\")(f)) quad upright(\"if\") quad f == upright(\"_t1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Operand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VecOperand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VecVecOperand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $], upright(\"EcxBodyIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])) quad upright(\"if\") quad f == upright(\"_t1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6685_5_MyTxEggccExtraction_add_rule__r0019__3fc4ed1b89e27094", + "display_name": "r0019", + "rule_name": "r0019", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 197316, + "line": 6685, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 197316, + "end": 197448 + }, + "pattern_range": { + "start": 197361, + "end": 197372 + }, + "action_range": { + "start": 197374, + "end": 197447 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "f: EcxBody", + "range": { + "start": 30161, + "end": 30191 + }, + "inputs": [] + }, + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 30196, + "end": 30237 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "outputs: EcxVecOperand", + "range": { + "start": 30242, + "end": 30284 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 30289, + "end": 30325 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxTheta", + "label": "_t1: EcxTheta", + "range": { + "start": 30330, + "end": 30382 + }, + "inputs": [ + "pred", + "inputs", + "outputs" + ] + }, + { + "id": "_rel2", + "kind": "query", + "dsl_type": "EcxOperand_is_pure", + "label": "_rel2: EcxOperand_is_pure", + "range": { + "start": 30387, + "end": 30432 + }, + "inputs": [ + "pred" + ] + }, + { + "id": "_rel3", + "kind": "query", + "dsl_type": "EcxVecOperand_is_pure", + "label": "_rel3: EcxVecOperand_is_pure", + "range": { + "start": 30437, + "end": 30487 + }, + "inputs": [ + "inputs" + ] + }, + { + "id": "_rel4", + "kind": "query", + "dsl_type": "EcxVecOperand_is_pure", + "label": "_rel4: EcxVecOperand_is_pure", + "range": { + "start": 30492, + "end": 30543 + }, + "inputs": [ + "outputs" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "outputs", + "kind": "operand", + "index": 2 + }, + { + "from": "_rel2", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel3", + "to": "inputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel4", + "to": "outputs", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "f", + "inputs", + "outputs", + "pred", + "_t1", + "_rel2", + "_rel3", + "_rel4" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 30663, + "end": 30665 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@197406:197440", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_body_is_pure(pat.f)", + "semantic_text": null, + "referenced_pat_vars": [ + "f" + ], + "referenced_action_vars": [], + "range": { + "start": 197406, + "end": 197440 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0019", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxTheta", + "plain_source": "upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "_rel2", + "label": "_rel2: EcxOperand_is_pure", + "plain_source": "upright(\"Operand_is_pure\")(upright(\"pred\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Operand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $]) $]" + }, + { + "target_id": "_rel3", + "label": "_rel3: EcxVecOperand_is_pure", + "plain_source": "upright(\"VecOperand_is_pure\")(upright(\"inputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VecOperand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $]" + }, + { + "target_id": "_rel4", + "label": "_rel4: EcxVecOperand_is_pure", + "plain_source": "upright(\"VecOperand_is_pure\")(upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VecOperand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + ], + "side_conditions": [ + "f == upright(\"_t1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyIsPure\")(f)", + "colored_source": "upright(\"EcxBodyIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyIsPure\")(f)", + "colored_source": "upright(\"EcxBodyIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\")) \\ upright(\"Operand_is_pure\")(upright(\"pred\")) \\ upright(\"VecOperand_is_pure\")(upright(\"inputs\")) \\ upright(\"VecOperand_is_pure\")(upright(\"outputs\")), upright(\"EcxBodyIsPure\")(f)) quad upright(\"if\") quad f == upright(\"_t1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Operand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VecOperand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VecOperand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $], upright(\"EcxBodyIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])) quad upright(\"if\") quad f == upright(\"_t1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6688_5_MyTxEggccExtraction_add_rule__r0020__250355538fd0f75f", + "display_name": "r0020", + "rule_name": "r0020", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 197454, + "line": 6688, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 197454, + "end": 197586 + }, + "pattern_range": { + "start": 197499, + "end": 197510 + }, + "action_range": { + "start": 197512, + "end": 197585 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "f: EcxBody", + "range": { + "start": 30880, + "end": 30910 + }, + "inputs": [] + }, + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "vec: EcxVecOperand", + "range": { + "start": 30915, + "end": 30953 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxOperandGroup", + "label": "_t1: EcxOperandGroup", + "range": { + "start": 30958, + "end": 30997 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_rel2", + "kind": "query", + "dsl_type": "EcxVecOperand_is_pure", + "label": "_rel2: EcxVecOperand_is_pure", + "range": { + "start": 31002, + "end": 31049 + }, + "inputs": [ + "vec" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel2", + "to": "vec", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "f", + "vec", + "_t1", + "_rel2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 31137, + "end": 31139 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@197544:197578", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_body_is_pure(pat.f)", + "semantic_text": null, + "referenced_pat_vars": [ + "f" + ], + "referenced_action_vars": [], + "range": { + "start": 197544, + "end": 197578 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0020", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxOperandGroup", + "plain_source": "upright(\"OperandGroup\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"OperandGroup\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + }, + { + "target_id": "_rel2", + "label": "_rel2: EcxVecOperand_is_pure", + "plain_source": "upright(\"VecOperand_is_pure\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VecOperand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + } + ], + "side_conditions": [ + "f == upright(\"_t1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyIsPure\")(f)", + "colored_source": "upright(\"EcxBodyIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyIsPure\")(f)", + "colored_source": "upright(\"EcxBodyIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"OperandGroup\")(upright(\"vec\")) \\ upright(\"VecOperand_is_pure\")(upright(\"vec\")), upright(\"EcxBodyIsPure\")(f)) quad upright(\"if\") quad f == upright(\"_t1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"OperandGroup\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VecOperand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], upright(\"EcxBodyIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])) quad upright(\"if\") quad f == upright(\"_t1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6691_5_MyTxEggccExtraction_add_rule__r0021__621db073fc4e1b7a", + "display_name": "r0021", + "rule_name": "r0021", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 197592, + "line": 6691, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 197592, + "end": 197728 + }, + "pattern_range": { + "start": 197637, + "end": 197648 + }, + "action_range": { + "start": 197650, + "end": 197727 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "f: EcxVecOperand", + "range": { + "start": 31320, + "end": 31356 + }, + "inputs": [] + }, + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "vec: EcxVecOperandBase", + "range": { + "start": 31361, + "end": 31403 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t1: EcxVO", + "range": { + "start": 31408, + "end": 31437 + }, + "inputs": [ + "vec" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "vec", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "f", + "vec", + "_t1" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 31518, + "end": 31520 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@197671:197720", + "bound_var": null, + "source_text": "ctx.set_ecx_vec_operand_pure_prefix(pat.f, 0_i64)", + "semantic_text": "ecx_vec_operand_pure_prefix(pat.f) = 0", + "referenced_pat_vars": [ + "f" + ], + "referenced_action_vars": [], + "range": { + "start": 197671, + "end": 197720 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0021", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + } + ], + "side_conditions": [ + "f == upright(\"_t1\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "effect_0", + "plain_source": "upright(\"ecx_vec_operand_pure_prefix\")(f) = 0", + "colored_source": "upright(\"ecx_vec_operand_pure_prefix\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $]) = #text(fill: rgb(\"#B86A5B\"))[$ 0 $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"VO\")(upright(\"vec\")), upright(\"ecx_vec_operand_pure_prefix\")(f) = 0) quad upright(\"if\") quad f == upright(\"_t1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], upright(\"ecx_vec_operand_pure_prefix\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $]) = #text(fill: rgb(\"#B86A5B\"))[$ 0 $]) quad upright(\"if\") quad f == upright(\"_t1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6694_5_MyTxEggccExtraction_add_rule__r0022__f370695b243a575c", + "display_name": "r0022", + "rule_name": "r0022", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 197734, + "line": 6694, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 197734, + "end": 197893 + }, + "pattern_range": { + "start": 197779, + "end": 197790 + }, + "action_range": { + "start": 197792, + "end": 197892 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "f: EcxVecOperand", + "range": { + "start": 31756, + "end": 31792 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 31797, + "end": 31842 + }, + "inputs": [] + }, + { + "id": "_f1", + "kind": "query", + "dsl_type": "EcxVecOperand_pure_prefix", + "label": "_f1: EcxVecOperand_pure_prefix", + "range": { + "start": 31847, + "end": 31894 + }, + "inputs": [ + "f" + ] + }, + { + "id": "_f2", + "kind": "query", + "dsl_type": "EcxVecOperand_length", + "label": "_f2: EcxVecOperand_length", + "range": { + "start": 31899, + "end": 31941 + }, + "inputs": [ + "f" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxVecOperand_get", + "label": "_t4: EcxVecOperand_get", + "range": { + "start": 31946, + "end": 31985 + }, + "inputs": [ + "f" + ] + }, + { + "id": "_rel3", + "kind": "query", + "dsl_type": "EcxOperand_is_pure", + "label": "_rel3: EcxOperand_is_pure", + "range": { + "start": 31990, + "end": 32034 + }, + "inputs": [ + "_t4" + ] + } + ], + "edges": [ + { + "from": "_f1", + "to": "f", + "kind": "operand", + "index": 0 + }, + { + "from": "_f2", + "to": "f", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "f", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel3", + "to": "_t4", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "f", + "i", + "_f1", + "_f2", + "_rel3", + "_t4" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_f1.handle())", + "semantic_text": "i == _f1", + "referenced_vars": [ + "_f1", + "i" + ], + "range": { + "start": 32228, + "end": 32230 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "i.handle().lt(&_f2.handle())", + "semantic_text": "i < _f2", + "referenced_vars": [ + "_f2", + "i" + ], + "range": { + "start": 32248, + "end": 32250 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "i.handle().eq(&_t4.handle_a1())", + "semantic_text": "i == _t4.a1", + "referenced_vars": [ + "_t4", + "i" + ], + "range": { + "start": 32268, + "end": 32270 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@197813:197885", + "bound_var": null, + "source_text": "ctx.set_ecx_vec_operand_pure_prefix(pat.f, (ctx.devalue(pat.i) + 1_i64))", + "semantic_text": "ecx_vec_operand_pure_prefix(pat.f) = ctx.devalue(pat.i) + 1", + "referenced_pat_vars": [ + "f", + "i" + ], + "referenced_action_vars": [], + "range": { + "start": 197813, + "end": 197885 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0022", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_f1", + "label": "_f1: EcxVecOperand_pure_prefix", + "plain_source": "upright(\"EcxVecOperand_pure_prefix\")(f)", + "colored_source": "upright(\"EcxVecOperand_pure_prefix\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + }, + { + "target_id": "_f2", + "label": "_f2: EcxVecOperand_length", + "plain_source": "upright(\"EcxVecOperand_length\")(f)", + "colored_source": "upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + }, + { + "target_id": "_rel3", + "label": "_rel3: EcxOperand_is_pure", + "plain_source": "upright(\"Operand_is_pure\")(upright(\"_t4\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Operand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $]) $]" + }, + { + "target_id": "_t4", + "label": "_t4: EcxVecOperand_get", + "plain_source": "upright(\"_t4\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $]" + } + ], + "side_conditions": [ + "i == upright(\"_f1\")", + "i < upright(\"_f2\")", + "i == upright(\"_t4.a1\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "effect_0", + "plain_source": "upright(\"ecx_vec_operand_pure_prefix\")(f) = i + 1", + "colored_source": "upright(\"ecx_vec_operand_pure_prefix\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $]) = #text(fill: rgb(\"#B86A5B\"))[$ i + 1 $]" + } + } + ], + "formula_source": { + "plain": "frac(i \\ upright(\"EcxVecOperand_pure_prefix\")(f) \\ upright(\"EcxVecOperand_length\")(f) \\ upright(\"Operand_is_pure\")(upright(\"_t4\")) \\ upright(\"_t4\"), upright(\"ecx_vec_operand_pure_prefix\")(f) = i + 1) quad upright(\"if\") quad i == upright(\"_f1\") \\ i < upright(\"_f2\") \\ i == upright(\"_t4.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ upright(\"EcxVecOperand_pure_prefix\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $]) \\ upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Operand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $], upright(\"ecx_vec_operand_pure_prefix\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $]) = #text(fill: rgb(\"#B86A5B\"))[$ i + 1 $]) quad upright(\"if\") quad i == upright(\"_f1\") \\ i < upright(\"_f2\") \\ i == upright(\"_t4.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6697_5_MyTxEggccExtraction_add_rule__r0023__910b31363140e07a", + "display_name": "r0023", + "rule_name": "r0023", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 197899, + "line": 6697, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 197899, + "end": 198038 + }, + "pattern_range": { + "start": 197944, + "end": 197955 + }, + "action_range": { + "start": 197957, + "end": 198037 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "f: EcxVecOperand", + "range": { + "start": 32435, + "end": 32471 + }, + "inputs": [] + }, + { + "id": "_f1", + "kind": "query", + "dsl_type": "EcxVecOperand_length", + "label": "_f1: EcxVecOperand_length", + "range": { + "start": 32476, + "end": 32518 + }, + "inputs": [ + "f" + ] + }, + { + "id": "_f2", + "kind": "query", + "dsl_type": "EcxVecOperand_pure_prefix", + "label": "_f2: EcxVecOperand_pure_prefix", + "range": { + "start": 32523, + "end": 32570 + }, + "inputs": [ + "f" + ] + } + ], + "edges": [ + { + "from": "_f1", + "to": "f", + "kind": "operand", + "index": 0 + }, + { + "from": "_f2", + "to": "f", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "f", + "_f1", + "_f2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "_f1.handle().eq(&_f2.handle())", + "semantic_text": "_f1 == _f2", + "referenced_vars": [ + "_f1", + "_f2" + ], + "range": { + "start": 32653, + "end": 32655 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@197989:198030", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_vec_operand_is_pure(pat.f)", + "semantic_text": null, + "referenced_pat_vars": [ + "f" + ], + "referenced_action_vars": [], + "range": { + "start": 197989, + "end": 198030 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0023", + "premises": [ + { + "target_id": "_f1", + "label": "_f1: EcxVecOperand_length", + "plain_source": "upright(\"EcxVecOperand_length\")(f)", + "colored_source": "upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + }, + { + "target_id": "_f2", + "label": "_f2: EcxVecOperand_pure_prefix", + "plain_source": "upright(\"EcxVecOperand_pure_prefix\")(f)", + "colored_source": "upright(\"EcxVecOperand_pure_prefix\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + ], + "side_conditions": [ + "upright(\"_f1\") == upright(\"_f2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxVecOperandIsPure\")(f)", + "colored_source": "upright(\"EcxVecOperandIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxVecOperandIsPure\")(f)", + "colored_source": "upright(\"EcxVecOperandIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"EcxVecOperand_length\")(f) \\ upright(\"EcxVecOperand_pure_prefix\")(f), upright(\"EcxVecOperandIsPure\")(f)) quad upright(\"if\") quad upright(\"_f1\") == upright(\"_f2\")", + "colored": "frac(upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $]) \\ upright(\"EcxVecOperand_pure_prefix\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $]), upright(\"EcxVecOperandIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])) quad upright(\"if\") quad upright(\"_f1\") == upright(\"_f2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6700_5_MyTxEggccExtraction_add_rule__r0024__d50d714c848af9e4", + "display_name": "r0024", + "rule_name": "r0024", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 198044, + "line": 6700, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 198044, + "end": 198184 + }, + "pattern_range": { + "start": 198089, + "end": 198100 + }, + "action_range": { + "start": 198102, + "end": 198183 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "f: EcxVecVecOperand", + "range": { + "start": 32843, + "end": 32882 + }, + "inputs": [] + }, + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperandBase", + "label": "vec: EcxVecVecOperandBase", + "range": { + "start": 32887, + "end": 32932 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t1: EcxVVO", + "range": { + "start": 32937, + "end": 32967 + }, + "inputs": [ + "vec" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "vec", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "f", + "vec", + "_t1" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 33048, + "end": 33050 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@198123:198176", + "bound_var": null, + "source_text": "ctx.set_ecx_vec_vec_operand_pure_prefix(pat.f, 0_i64)", + "semantic_text": "ecx_vec_vec_operand_pure_prefix(pat.f) = 0", + "referenced_pat_vars": [ + "f" + ], + "referenced_action_vars": [], + "range": { + "start": 198123, + "end": 198176 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0024", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + } + ], + "side_conditions": [ + "f == upright(\"_t1\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "effect_0", + "plain_source": "upright(\"ecx_vec_vec_operand_pure_prefix\")(f) = 0", + "colored_source": "upright(\"ecx_vec_vec_operand_pure_prefix\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $]) = #text(fill: rgb(\"#B86A5B\"))[$ 0 $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"VVO\")(upright(\"vec\")), upright(\"ecx_vec_vec_operand_pure_prefix\")(f) = 0) quad upright(\"if\") quad f == upright(\"_t1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], upright(\"ecx_vec_vec_operand_pure_prefix\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $]) = #text(fill: rgb(\"#B86A5B\"))[$ 0 $]) quad upright(\"if\") quad f == upright(\"_t1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6703_5_MyTxEggccExtraction_add_rule__r0025__9e9eb31363f5fbea", + "display_name": "r0025", + "rule_name": "r0025", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 198190, + "line": 6703, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 198190, + "end": 198353 + }, + "pattern_range": { + "start": 198235, + "end": 198246 + }, + "action_range": { + "start": 198248, + "end": 198352 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "f: EcxVecVecOperand", + "range": { + "start": 33295, + "end": 33334 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 33339, + "end": 33384 + }, + "inputs": [] + }, + { + "id": "_f1", + "kind": "query", + "dsl_type": "EcxVecVecOperand_pure_prefix", + "label": "_f1: EcxVecVecOperand_pure_prefix", + "range": { + "start": 33389, + "end": 33439 + }, + "inputs": [ + "f" + ] + }, + { + "id": "_f2", + "kind": "query", + "dsl_type": "EcxVecVecOperand_length", + "label": "_f2: EcxVecVecOperand_length", + "range": { + "start": 33444, + "end": 33489 + }, + "inputs": [ + "f" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxVecVecOperand_get", + "label": "_t4: EcxVecVecOperand_get", + "range": { + "start": 33494, + "end": 33536 + }, + "inputs": [ + "f" + ] + }, + { + "id": "_rel3", + "kind": "query", + "dsl_type": "EcxVecOperand_is_pure", + "label": "_rel3: EcxVecOperand_is_pure", + "range": { + "start": 33541, + "end": 33588 + }, + "inputs": [ + "_t4" + ] + } + ], + "edges": [ + { + "from": "_f1", + "to": "f", + "kind": "operand", + "index": 0 + }, + { + "from": "_f2", + "to": "f", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "f", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel3", + "to": "_t4", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "f", + "i", + "_f1", + "_f2", + "_rel3", + "_t4" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_f1.handle())", + "semantic_text": "i == _f1", + "referenced_vars": [ + "_f1", + "i" + ], + "range": { + "start": 33782, + "end": 33784 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "i.handle().lt(&_f2.handle())", + "semantic_text": "i < _f2", + "referenced_vars": [ + "_f2", + "i" + ], + "range": { + "start": 33802, + "end": 33804 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "i.handle().eq(&_t4.handle_a1())", + "semantic_text": "i == _t4.a1", + "referenced_vars": [ + "_t4", + "i" + ], + "range": { + "start": 33822, + "end": 33824 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@198269:198345", + "bound_var": null, + "source_text": "ctx.set_ecx_vec_vec_operand_pure_prefix(pat.f, (ctx.devalue(pat.i) + 1_i64))", + "semantic_text": "ecx_vec_vec_operand_pure_prefix(pat.f) = ctx.devalue(pat.i) + 1", + "referenced_pat_vars": [ + "f", + "i" + ], + "referenced_action_vars": [], + "range": { + "start": 198269, + "end": 198345 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0025", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_f1", + "label": "_f1: EcxVecVecOperand_pure_prefix", + "plain_source": "upright(\"EcxVecVecOperand_pure_prefix\")(f)", + "colored_source": "upright(\"EcxVecVecOperand_pure_prefix\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + }, + { + "target_id": "_f2", + "label": "_f2: EcxVecVecOperand_length", + "plain_source": "upright(\"EcxVecVecOperand_length\")(f)", + "colored_source": "upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + }, + { + "target_id": "_rel3", + "label": "_rel3: EcxVecOperand_is_pure", + "plain_source": "upright(\"VecOperand_is_pure\")(upright(\"_t4\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VecOperand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $]) $]" + }, + { + "target_id": "_t4", + "label": "_t4: EcxVecVecOperand_get", + "plain_source": "upright(\"_t4\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $]" + } + ], + "side_conditions": [ + "i == upright(\"_f1\")", + "i < upright(\"_f2\")", + "i == upright(\"_t4.a1\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "effect_0", + "plain_source": "upright(\"ecx_vec_vec_operand_pure_prefix\")(f) = i + 1", + "colored_source": "upright(\"ecx_vec_vec_operand_pure_prefix\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $]) = #text(fill: rgb(\"#B86A5B\"))[$ i + 1 $]" + } + } + ], + "formula_source": { + "plain": "frac(i \\ upright(\"EcxVecVecOperand_pure_prefix\")(f) \\ upright(\"EcxVecVecOperand_length\")(f) \\ upright(\"VecOperand_is_pure\")(upright(\"_t4\")) \\ upright(\"_t4\"), upright(\"ecx_vec_vec_operand_pure_prefix\")(f) = i + 1) quad upright(\"if\") quad i == upright(\"_f1\") \\ i < upright(\"_f2\") \\ i == upright(\"_t4.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ upright(\"EcxVecVecOperand_pure_prefix\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $]) \\ upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VecOperand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $], upright(\"ecx_vec_vec_operand_pure_prefix\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $]) = #text(fill: rgb(\"#B86A5B\"))[$ i + 1 $]) quad upright(\"if\") quad i == upright(\"_f1\") \\ i < upright(\"_f2\") \\ i == upright(\"_t4.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6706_5_MyTxEggccExtraction_add_rule__r0026__97d128dac42a5204", + "display_name": "r0026", + "rule_name": "r0026", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 198359, + "line": 6706, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 198359, + "end": 198502 + }, + "pattern_range": { + "start": 198404, + "end": 198415 + }, + "action_range": { + "start": 198417, + "end": 198501 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "f: EcxVecVecOperand", + "range": { + "start": 33992, + "end": 34031 + }, + "inputs": [] + }, + { + "id": "_f1", + "kind": "query", + "dsl_type": "EcxVecVecOperand_length", + "label": "_f1: EcxVecVecOperand_length", + "range": { + "start": 34036, + "end": 34081 + }, + "inputs": [ + "f" + ] + }, + { + "id": "_f2", + "kind": "query", + "dsl_type": "EcxVecVecOperand_pure_prefix", + "label": "_f2: EcxVecVecOperand_pure_prefix", + "range": { + "start": 34086, + "end": 34136 + }, + "inputs": [ + "f" + ] + } + ], + "edges": [ + { + "from": "_f1", + "to": "f", + "kind": "operand", + "index": 0 + }, + { + "from": "_f2", + "to": "f", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "f", + "_f1", + "_f2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "_f1.handle().eq(&_f2.handle())", + "semantic_text": "_f1 == _f2", + "referenced_vars": [ + "_f1", + "_f2" + ], + "range": { + "start": 34219, + "end": 34221 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@198449:198494", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_vec_vec_operand_is_pure(pat.f)", + "semantic_text": null, + "referenced_pat_vars": [ + "f" + ], + "referenced_action_vars": [], + "range": { + "start": 198449, + "end": 198494 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0026", + "premises": [ + { + "target_id": "_f1", + "label": "_f1: EcxVecVecOperand_length", + "plain_source": "upright(\"EcxVecVecOperand_length\")(f)", + "colored_source": "upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + }, + { + "target_id": "_f2", + "label": "_f2: EcxVecVecOperand_pure_prefix", + "plain_source": "upright(\"EcxVecVecOperand_pure_prefix\")(f)", + "colored_source": "upright(\"EcxVecVecOperand_pure_prefix\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + ], + "side_conditions": [ + "upright(\"_f1\") == upright(\"_f2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxVecVecOperandIsPure\")(f)", + "colored_source": "upright(\"EcxVecVecOperandIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxVecVecOperandIsPure\")(f)", + "colored_source": "upright(\"EcxVecVecOperandIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"EcxVecVecOperand_length\")(f) \\ upright(\"EcxVecVecOperand_pure_prefix\")(f), upright(\"EcxVecVecOperandIsPure\")(f)) quad upright(\"if\") quad upright(\"_f1\") == upright(\"_f2\")", + "colored": "frac(upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $]) \\ upright(\"EcxVecVecOperand_pure_prefix\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $]), upright(\"EcxVecVecOperandIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])) quad upright(\"if\") quad upright(\"_f1\") == upright(\"_f2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6709_5_MyTxEggccExtraction_add_rule__r0027__f7c6434493bc3296", + "display_name": "r0027", + "rule_name": "r0027", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 198508, + "line": 6709, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 198508, + "end": 198644 + }, + "pattern_range": { + "start": 198553, + "end": 198564 + }, + "action_range": { + "start": 198566, + "end": 198643 + } + }, + "nodes": [ + { + "id": "body", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "body: EcxVecOperand", + "range": { + "start": 34512, + "end": 34551 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxFunction", + "label": "f: EcxFunction", + "range": { + "start": 34556, + "end": 34590 + }, + "inputs": [] + }, + { + "id": "input_types", + "kind": "query_leaf", + "dsl_type": "EcxFuncSigs", + "label": "input_types: EcxFuncSigs", + "range": { + "start": 34595, + "end": 34639 + }, + "inputs": [] + }, + { + "id": "name", + "kind": "query", + "dsl_type": "", + "label": "name: ", + "range": { + "start": 34644, + "end": 34698 + }, + "inputs": [] + }, + { + "id": "output_types", + "kind": "query_leaf", + "dsl_type": "EcxFuncSigs", + "label": "output_types: EcxFuncSigs", + "range": { + "start": 34703, + "end": 34748 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxFunc", + "label": "_t1: EcxFunc", + "range": { + "start": 34753, + "end": 34814 + }, + "inputs": [ + "input_types", + "output_types", + "body" + ] + }, + { + "id": "_rel2", + "kind": "query", + "dsl_type": "EcxVecOperand_is_pure", + "label": "_rel2: EcxVecOperand_is_pure", + "range": { + "start": 34819, + "end": 34867 + }, + "inputs": [ + "body" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "input_types", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "output_types", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "body", + "kind": "operand", + "index": 2 + }, + { + "from": "_rel2", + "to": "body", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "body", + "f", + "input_types", + "name", + "output_types", + "_t1", + "_rel2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "name.handle().eq(&_t1.handle_a0())", + "semantic_text": "name == _t1.a0", + "referenced_vars": [ + "_t1", + "name" + ], + "range": { + "start": 35047, + "end": 35049 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 35067, + "end": 35069 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@198598:198636", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_function_is_pure(pat.f)", + "semantic_text": null, + "referenced_pat_vars": [ + "f" + ], + "referenced_action_vars": [], + "range": { + "start": 198598, + "end": 198636 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0027", + "premises": [ + { + "target_id": "name", + "label": "name: ", + "plain_source": "upright(\"name\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"name\") $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxFunc", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_rel2", + "label": "_rel2: EcxVecOperand_is_pure", + "plain_source": "upright(\"VecOperand_is_pure\")(upright(\"body\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VecOperand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $]) $]" + } + ], + "side_conditions": [ + "upright(\"name\") == upright(\"_t1.a0\")", + "f == upright(\"_t1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxFunctionIsPure\")(f)", + "colored_source": "upright(\"EcxFunctionIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxFunctionIsPure\")(f)", + "colored_source": "upright(\"EcxFunctionIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"name\") \\ upright(\"_t1\") \\ upright(\"VecOperand_is_pure\")(upright(\"body\")), upright(\"EcxFunctionIsPure\")(f)) quad upright(\"if\") quad upright(\"name\") == upright(\"_t1.a0\") \\ f == upright(\"_t1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"name\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VecOperand_is_pure\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $]) $], upright(\"EcxFunctionIsPure\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $])) quad upright(\"if\") quad upright(\"name\") == upright(\"_t1.a0\") \\ f == upright(\"_t1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6712_5_MyTxEggccExtraction_add_rule__r0028__47d7ebff24d0a91f", + "display_name": "r0028", + "rule_name": "r0028", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 198650, + "line": 6712, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 198650, + "end": 198802 + }, + "pattern_range": { + "start": 198695, + "end": 198706 + }, + "action_range": { + "start": 198708, + "end": 198801 + } + }, + "nodes": [ + { + "id": "e", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "e: EcxExpr", + "range": { + "start": 35236, + "end": 35266 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "f: EcxBody", + "range": { + "start": 35271, + "end": 35301 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t1: EcxPureOp", + "range": { + "start": 35306, + "end": 35337 + }, + "inputs": [ + "e" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "e", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "e", + "f", + "_t1" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 35416, + "end": 35418 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@198740:198794", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_body_contains_expr(pat.f, 0_i64, pat.e)", + "semantic_text": null, + "referenced_pat_vars": [ + "e", + "f" + ], + "referenced_action_vars": [], + "range": { + "start": 198740, + "end": 198794 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0028", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxPureOp", + "plain_source": "upright(\"PureOp\")(e)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $]) $]" + } + ], + "side_conditions": [ + "f == upright(\"_t1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsExpr\")(f, 0, e)", + "colored_source": "upright(\"EcxBodyContainsExpr\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#B86A5B\"))[$ 0 $], #text(fill: rgb(\"#5F7A8A\"))[$ e $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsExpr\")(f, 0, e)", + "colored_source": "upright(\"EcxBodyContainsExpr\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#B86A5B\"))[$ 0 $], #text(fill: rgb(\"#5F7A8A\"))[$ e $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"PureOp\")(e), upright(\"EcxBodyContainsExpr\")(f, 0, e)) quad upright(\"if\") quad f == upright(\"_t1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $]) $], upright(\"EcxBodyContainsExpr\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#B86A5B\"))[$ 0 $], #text(fill: rgb(\"#5F7A8A\"))[$ e $])) quad upright(\"if\") quad f == upright(\"_t1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6715_5_MyTxEggccExtraction_add_rule__r0029__e5676affaf71a829", + "display_name": "r0029", + "rule_name": "r0029", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 198808, + "line": 6715, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 198808, + "end": 198976 + }, + "pattern_range": { + "start": 198853, + "end": 198864 + }, + "action_range": { + "start": 198866, + "end": 198975 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "f: EcxBody", + "range": { + "start": 35780, + "end": 35810 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 35815, + "end": 35860 + }, + "inputs": [] + }, + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 35865, + "end": 35906 + }, + "inputs": [] + }, + { + "id": "j", + "kind": "query", + "dsl_type": "", + "label": "j: ", + "range": { + "start": 35911, + "end": 35956 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "outputs: EcxVecVecOperand", + "range": { + "start": 35961, + "end": 36006 + }, + "inputs": [] + }, + { + "id": "outputs_i", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "outputs_i: EcxVecOperand", + "range": { + "start": 36011, + "end": 36055 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 36060, + "end": 36096 + }, + "inputs": [] + }, + { + "id": "x", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "x: EcxOperand", + "range": { + "start": 36101, + "end": 36134 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxGamma", + "label": "_t1: EcxGamma", + "range": { + "start": 36139, + "end": 36191 + }, + "inputs": [ + "pred", + "inputs", + "outputs" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVecVecOperand_get", + "label": "_t2: EcxVecVecOperand_get", + "range": { + "start": 36196, + "end": 36244 + }, + "inputs": [ + "outputs" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxVecOperand_get", + "label": "_t3: EcxVecOperand_get", + "range": { + "start": 36249, + "end": 36296 + }, + "inputs": [ + "outputs_i" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "outputs", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "outputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t3", + "to": "outputs_i", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "f", + "i", + "inputs", + "j", + "outputs", + "outputs_i", + "pred", + "x", + "_t1", + "_t2", + "_t3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 36620, + "end": 36622 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "i.handle().eq(&_t2.handle_a1())", + "semantic_text": "i == _t2.a1", + "referenced_vars": [ + "_t2", + "i" + ], + "range": { + "start": 36640, + "end": 36642 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "outputs_i.handle().eq(&_t2.handle())", + "semantic_text": "outputs_i == _t2", + "referenced_vars": [ + "_t2", + "outputs_i" + ], + "range": { + "start": 36660, + "end": 36662 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "j.handle().eq(&_t3.handle_a1())", + "semantic_text": "j == _t3.a1", + "referenced_vars": [ + "_t3", + "j" + ], + "range": { + "start": 36680, + "end": 36682 + } + }, + { + "id": "constraint_4", + "source_text": "c4", + "resolved_text": "x.handle().eq(&_t3.handle())", + "semantic_text": "x == _t3", + "referenced_vars": [ + "_t3", + "x" + ], + "range": { + "start": 36700, + "end": 36702 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@198898:198968", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_body_contains_operand(pat.f, ctx.devalue(pat.i), pat.x)", + "semantic_text": null, + "referenced_pat_vars": [ + "f", + "i", + "x" + ], + "referenced_action_vars": [], + "range": { + "start": 198898, + "end": 198968 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0029", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "j", + "label": "j: ", + "plain_source": "j", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ j $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxGamma", + "plain_source": "upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVecVecOperand_get", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxVecOperand_get", + "plain_source": "upright(\"_t3\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]" + } + ], + "side_conditions": [ + "f == upright(\"_t1\")", + "i == upright(\"_t2.a1\")", + "upright(\"outputs_i\") == upright(\"_t2\")", + "j == upright(\"_t3.a1\")", + "x == upright(\"_t3\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, x)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ x $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, x)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ x $])" + } + } + ], + "formula_source": { + "plain": "frac(i \\ j \\ upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\")) \\ upright(\"_t2\") \\ upright(\"_t3\"), upright(\"EcxBodyContainsOperand\")(f, i, x)) quad upright(\"if\") quad f == upright(\"_t1\") \\ i == upright(\"_t2.a1\") \\ upright(\"outputs_i\") == upright(\"_t2\") \\ j == upright(\"_t3.a1\") \\ x == upright(\"_t3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ j $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $], upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ x $])) quad upright(\"if\") quad f == upright(\"_t1\") \\ i == upright(\"_t2.a1\") \\ upright(\"outputs_i\") == upright(\"_t2\") \\ j == upright(\"_t3.a1\") \\ x == upright(\"_t3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6718_5_MyTxEggccExtraction_add_rule__r0030__e8cdae54a1080260", + "display_name": "r0030", + "rule_name": "r0030", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 198982, + "line": 6718, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 198982, + "end": 199141 + }, + "pattern_range": { + "start": 199027, + "end": 199038 + }, + "action_range": { + "start": 199040, + "end": 199140 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "f: EcxBody", + "range": { + "start": 36929, + "end": 36959 + }, + "inputs": [] + }, + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 36964, + "end": 37005 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "outputs: EcxVecOperand", + "range": { + "start": 37010, + "end": 37052 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 37057, + "end": 37093 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxTheta", + "label": "_t1: EcxTheta", + "range": { + "start": 37098, + "end": 37150 + }, + "inputs": [ + "pred", + "inputs", + "outputs" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "outputs", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "f", + "inputs", + "outputs", + "pred", + "_t1" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 37249, + "end": 37251 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@199072:199133", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_body_contains_operand(pat.f, -1_i64, pat.pred)", + "semantic_text": null, + "referenced_pat_vars": [ + "f", + "pred" + ], + "referenced_action_vars": [], + "range": { + "start": 199072, + "end": 199133 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0030", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxTheta", + "plain_source": "upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + ], + "side_conditions": [ + "f == upright(\"_t1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, -1, upright(\"pred\"))", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#B86A5B\"))[$ -1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, -1, upright(\"pred\"))", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#B86A5B\"))[$ -1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\")), upright(\"EcxBodyContainsOperand\")(f, -1, upright(\"pred\"))) quad upright(\"if\") quad f == upright(\"_t1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $], upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#B86A5B\"))[$ -1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $])) quad upright(\"if\") quad f == upright(\"_t1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6721_5_MyTxEggccExtraction_add_rule__r0031__a218fb3d60e5fef3", + "display_name": "r0031", + "rule_name": "r0031", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 199147, + "line": 6721, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 199147, + "end": 199315 + }, + "pattern_range": { + "start": 199192, + "end": 199203 + }, + "action_range": { + "start": 199205, + "end": 199314 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "f: EcxBody", + "range": { + "start": 37537, + "end": 37567 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 37572, + "end": 37617 + }, + "inputs": [] + }, + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 37622, + "end": 37663 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "outputs: EcxVecOperand", + "range": { + "start": 37668, + "end": 37710 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 37715, + "end": 37751 + }, + "inputs": [] + }, + { + "id": "x", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "x: EcxOperand", + "range": { + "start": 37756, + "end": 37789 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxTheta", + "label": "_t1: EcxTheta", + "range": { + "start": 37794, + "end": 37846 + }, + "inputs": [ + "pred", + "inputs", + "outputs" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVecOperand_get", + "label": "_t2: EcxVecOperand_get", + "range": { + "start": 37851, + "end": 37896 + }, + "inputs": [ + "outputs" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "outputs", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "outputs", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "f", + "i", + "inputs", + "outputs", + "pred", + "x", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 38104, + "end": 38106 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "i.handle().eq(&_t2.handle_a1())", + "semantic_text": "i == _t2.a1", + "referenced_vars": [ + "_t2", + "i" + ], + "range": { + "start": 38124, + "end": 38126 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "x.handle().eq(&_t2.handle())", + "semantic_text": "x == _t2", + "referenced_vars": [ + "_t2", + "x" + ], + "range": { + "start": 38144, + "end": 38146 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@199237:199307", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_body_contains_operand(pat.f, ctx.devalue(pat.i), pat.x)", + "semantic_text": null, + "referenced_pat_vars": [ + "f", + "i", + "x" + ], + "referenced_action_vars": [], + "range": { + "start": 199237, + "end": 199307 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0031", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxTheta", + "plain_source": "upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVecOperand_get", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + } + ], + "side_conditions": [ + "f == upright(\"_t1\")", + "i == upright(\"_t2.a1\")", + "x == upright(\"_t2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, x)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ x $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, x)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ x $])" + } + } + ], + "formula_source": { + "plain": "frac(i \\ upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\")) \\ upright(\"_t2\"), upright(\"EcxBodyContainsOperand\")(f, i, x)) quad upright(\"if\") quad f == upright(\"_t1\") \\ i == upright(\"_t2.a1\") \\ x == upright(\"_t2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ x $])) quad upright(\"if\") quad f == upright(\"_t1\") \\ i == upright(\"_t2.a1\") \\ x == upright(\"_t2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6724_5_MyTxEggccExtraction_add_rule__r0032__78f703f641dfa165", + "display_name": "r0032", + "rule_name": "r0032", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 199321, + "line": 6724, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 199321, + "end": 199489 + }, + "pattern_range": { + "start": 199366, + "end": 199377 + }, + "action_range": { + "start": 199379, + "end": 199488 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "f: EcxBody", + "range": { + "start": 38386, + "end": 38416 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 38421, + "end": 38466 + }, + "inputs": [] + }, + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "vec: EcxVecOperand", + "range": { + "start": 38471, + "end": 38509 + }, + "inputs": [] + }, + { + "id": "x", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "x: EcxOperand", + "range": { + "start": 38514, + "end": 38547 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxOperandGroup", + "label": "_t1: EcxOperandGroup", + "range": { + "start": 38552, + "end": 38591 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVecOperand_get", + "label": "_t2: EcxVecOperand_get", + "range": { + "start": 38596, + "end": 38637 + }, + "inputs": [ + "vec" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "vec", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "f", + "i", + "vec", + "x", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 38827, + "end": 38829 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "i.handle().eq(&_t2.handle_a1())", + "semantic_text": "i == _t2.a1", + "referenced_vars": [ + "_t2", + "i" + ], + "range": { + "start": 38847, + "end": 38849 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "x.handle().eq(&_t2.handle())", + "semantic_text": "x == _t2", + "referenced_vars": [ + "_t2", + "x" + ], + "range": { + "start": 38867, + "end": 38869 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@199411:199481", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_body_contains_operand(pat.f, ctx.devalue(pat.i), pat.x)", + "semantic_text": null, + "referenced_pat_vars": [ + "f", + "i", + "x" + ], + "referenced_action_vars": [], + "range": { + "start": 199411, + "end": 199481 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0032", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxOperandGroup", + "plain_source": "upright(\"OperandGroup\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"OperandGroup\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVecOperand_get", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + } + ], + "side_conditions": [ + "f == upright(\"_t1\")", + "i == upright(\"_t2.a1\")", + "x == upright(\"_t2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, x)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ x $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, x)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ x $])" + } + } + ], + "formula_source": { + "plain": "frac(i \\ upright(\"OperandGroup\")(upright(\"vec\")) \\ upright(\"_t2\"), upright(\"EcxBodyContainsOperand\")(f, i, x)) quad upright(\"if\") quad f == upright(\"_t1\") \\ i == upright(\"_t2.a1\") \\ x == upright(\"_t2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"OperandGroup\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ x $])) quad upright(\"if\") quad f == upright(\"_t1\") \\ i == upright(\"_t2.a1\") \\ x == upright(\"_t2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6727_5_MyTxEggccExtraction_add_rule__r0033__642c786ce2d360cf", + "display_name": "r0033", + "rule_name": "r0033", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 199495, + "line": 6727, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 199495, + "end": 199660 + }, + "pattern_range": { + "start": 199540, + "end": 199551 + }, + "action_range": { + "start": 199553, + "end": 199659 + } + }, + "nodes": [ + { + "id": "e", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "e: EcxExpr", + "range": { + "start": 39082, + "end": 39112 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "f: EcxBody", + "range": { + "start": 39117, + "end": 39147 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 39152, + "end": 39197 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t2: EcxPureOp", + "range": { + "start": 39202, + "end": 39233 + }, + "inputs": [ + "e" + ] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "EcxBody_contains_Body", + "label": "_rel1: EcxBody_contains_Body", + "range": { + "start": 39238, + "end": 39289 + }, + "inputs": [ + "f", + "_t2" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "e", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "f", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "_t2", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "e", + "f", + "i", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_rel1.handle_a1())", + "semantic_text": "i == _rel1.a1", + "referenced_vars": [ + "_rel1", + "i" + ], + "range": { + "start": 39383, + "end": 39385 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@199585:199652", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_body_contains_expr(pat.f, ctx.devalue(pat.i), pat.e)", + "semantic_text": null, + "referenced_pat_vars": [ + "e", + "f", + "i" + ], + "referenced_action_vars": [], + "range": { + "start": 199585, + "end": 199652 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0033", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_rel1", + "label": "_rel1: EcxBody_contains_Body", + "plain_source": "upright(\"_rel1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_rel1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxPureOp", + "plain_source": "upright(\"PureOp\")(e)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $]) $]" + } + ], + "side_conditions": [ + "i == upright(\"_rel1.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsExpr\")(f, i, e)", + "colored_source": "upright(\"EcxBodyContainsExpr\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsExpr\")(f, i, e)", + "colored_source": "upright(\"EcxBodyContainsExpr\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e $])" + } + } + ], + "formula_source": { + "plain": "frac(i \\ upright(\"_rel1\") \\ upright(\"PureOp\")(e), upright(\"EcxBodyContainsExpr\")(f, i, e)) quad upright(\"if\") quad i == upright(\"_rel1.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_rel1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $]) $], upright(\"EcxBodyContainsExpr\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e $])) quad upright(\"if\") quad i == upright(\"_rel1.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6730_5_MyTxEggccExtraction_add_rule__r0034__bd53765e07cb09ae", + "display_name": "r0034", + "rule_name": "r0034", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 199666, + "line": 6730, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 199666, + "end": 199837 + }, + "pattern_range": { + "start": 199711, + "end": 199722 + }, + "action_range": { + "start": 199724, + "end": 199836 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "f: EcxBody", + "range": { + "start": 39661, + "end": 39691 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 39696, + "end": 39741 + }, + "inputs": [] + }, + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 39746, + "end": 39787 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "outputs: EcxVecVecOperand", + "range": { + "start": 39792, + "end": 39837 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 39842, + "end": 39878 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxGamma", + "label": "_t2: EcxGamma", + "range": { + "start": 39883, + "end": 39935 + }, + "inputs": [ + "pred", + "inputs", + "outputs" + ] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "EcxBody_contains_Body", + "label": "_rel1: EcxBody_contains_Body", + "range": { + "start": 39940, + "end": 39991 + }, + "inputs": [ + "f", + "_t2" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "outputs", + "kind": "operand", + "index": 2 + }, + { + "from": "_rel1", + "to": "f", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "_t2", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "f", + "i", + "inputs", + "outputs", + "pred", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_rel1.handle_a1())", + "semantic_text": "i == _rel1.a1", + "referenced_vars": [ + "_rel1", + "i" + ], + "range": { + "start": 40105, + "end": 40107 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@199756:199829", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_body_contains_operand(pat.f, ctx.devalue(pat.i), pat.pred)", + "semantic_text": null, + "referenced_pat_vars": [ + "f", + "i", + "pred" + ], + "referenced_action_vars": [], + "range": { + "start": 199756, + "end": 199829 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0034", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_rel1", + "label": "_rel1: EcxBody_contains_Body", + "plain_source": "upright(\"_rel1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_rel1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxGamma", + "plain_source": "upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + ], + "side_conditions": [ + "i == upright(\"_rel1.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, upright(\"pred\"))", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, upright(\"pred\"))", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $])" + } + } + ], + "formula_source": { + "plain": "frac(i \\ upright(\"_rel1\") \\ upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\")), upright(\"EcxBodyContainsOperand\")(f, i, upright(\"pred\"))) quad upright(\"if\") quad i == upright(\"_rel1.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_rel1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $], upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $])) quad upright(\"if\") quad i == upright(\"_rel1.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6733_5_MyTxEggccExtraction_add_rule__r0035__ec78071a3b9ddbb8", + "display_name": "r0035", + "rule_name": "r0035", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 199843, + "line": 6733, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 199843, + "end": 200011 + }, + "pattern_range": { + "start": 199888, + "end": 199899 + }, + "action_range": { + "start": 199901, + "end": 200010 + } + }, + "nodes": [ + { + "id": "any", + "kind": "query", + "dsl_type": "", + "label": "any: ", + "range": { + "start": 40444, + "end": 40493 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "f: EcxBody", + "range": { + "start": 40498, + "end": 40528 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 40533, + "end": 40578 + }, + "inputs": [] + }, + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 40583, + "end": 40624 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "outputs: EcxVecVecOperand", + "range": { + "start": 40629, + "end": 40674 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 40679, + "end": 40715 + }, + "inputs": [] + }, + { + "id": "x", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "x: EcxOperand", + "range": { + "start": 40720, + "end": 40753 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxGamma", + "label": "_t2: EcxGamma", + "range": { + "start": 40758, + "end": 40810 + }, + "inputs": [ + "pred", + "inputs", + "outputs" + ] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "EcxBody_contains_Body", + "label": "_rel1: EcxBody_contains_Body", + "range": { + "start": 40815, + "end": 40866 + }, + "inputs": [ + "f", + "_t2" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxVecOperand_get", + "label": "_t3: EcxVecOperand_get", + "range": { + "start": 40871, + "end": 40915 + }, + "inputs": [ + "inputs" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "outputs", + "kind": "operand", + "index": 2 + }, + { + "from": "_rel1", + "to": "f", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "_t2", + "kind": "operand", + "index": 1 + }, + { + "from": "_t3", + "to": "inputs", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "any", + "f", + "i", + "inputs", + "outputs", + "pred", + "x", + "_rel1", + "_t2", + "_t3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_rel1.handle_a1())", + "semantic_text": "i == _rel1.a1", + "referenced_vars": [ + "_rel1", + "i" + ], + "range": { + "start": 41142, + "end": 41144 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "any.handle().eq(&_t3.handle_a1())", + "semantic_text": "any == _t3.a1", + "referenced_vars": [ + "_t3", + "any" + ], + "range": { + "start": 41162, + "end": 41164 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "x.handle().eq(&_t3.handle())", + "semantic_text": "x == _t3", + "referenced_vars": [ + "_t3", + "x" + ], + "range": { + "start": 41182, + "end": 41184 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@199933:200003", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_body_contains_operand(pat.f, ctx.devalue(pat.i), pat.x)", + "semantic_text": null, + "referenced_pat_vars": [ + "f", + "i", + "x" + ], + "referenced_action_vars": [], + "range": { + "start": 199933, + "end": 200003 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0035", + "premises": [ + { + "target_id": "any", + "label": "any: ", + "plain_source": "upright(\"any\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"any\") $]" + }, + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_rel1", + "label": "_rel1: EcxBody_contains_Body", + "plain_source": "upright(\"_rel1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_rel1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxGamma", + "plain_source": "upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxVecOperand_get", + "plain_source": "upright(\"_t3\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]" + } + ], + "side_conditions": [ + "i == upright(\"_rel1.a1\")", + "upright(\"any\") == upright(\"_t3.a1\")", + "x == upright(\"_t3\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, x)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ x $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, x)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ x $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"any\") \\ i \\ upright(\"_rel1\") \\ upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\")) \\ upright(\"_t3\"), upright(\"EcxBodyContainsOperand\")(f, i, x)) quad upright(\"if\") quad i == upright(\"_rel1.a1\") \\ upright(\"any\") == upright(\"_t3.a1\") \\ x == upright(\"_t3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"any\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_rel1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $], upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ x $])) quad upright(\"if\") quad i == upright(\"_rel1.a1\") \\ upright(\"any\") == upright(\"_t3.a1\") \\ x == upright(\"_t3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6736_5_MyTxEggccExtraction_add_rule__r0036__c8d9a12be18c4aca", + "display_name": "r0036", + "rule_name": "r0036", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 200017, + "line": 6736, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 200017, + "end": 200185 + }, + "pattern_range": { + "start": 200062, + "end": 200073 + }, + "action_range": { + "start": 200075, + "end": 200184 + } + }, + "nodes": [ + { + "id": "any", + "kind": "query", + "dsl_type": "", + "label": "any: ", + "range": { + "start": 41518, + "end": 41567 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "f: EcxBody", + "range": { + "start": 41572, + "end": 41602 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 41607, + "end": 41652 + }, + "inputs": [] + }, + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 41657, + "end": 41698 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "outputs: EcxVecOperand", + "range": { + "start": 41703, + "end": 41745 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 41750, + "end": 41786 + }, + "inputs": [] + }, + { + "id": "x", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "x: EcxOperand", + "range": { + "start": 41791, + "end": 41824 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxTheta", + "label": "_t2: EcxTheta", + "range": { + "start": 41829, + "end": 41881 + }, + "inputs": [ + "pred", + "inputs", + "outputs" + ] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "EcxBody_contains_Body", + "label": "_rel1: EcxBody_contains_Body", + "range": { + "start": 41886, + "end": 41937 + }, + "inputs": [ + "f", + "_t2" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxVecOperand_get", + "label": "_t3: EcxVecOperand_get", + "range": { + "start": 41942, + "end": 41986 + }, + "inputs": [ + "inputs" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "outputs", + "kind": "operand", + "index": 2 + }, + { + "from": "_rel1", + "to": "f", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "_t2", + "kind": "operand", + "index": 1 + }, + { + "from": "_t3", + "to": "inputs", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "any", + "f", + "i", + "inputs", + "outputs", + "pred", + "x", + "_rel1", + "_t2", + "_t3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_rel1.handle_a1())", + "semantic_text": "i == _rel1.a1", + "referenced_vars": [ + "_rel1", + "i" + ], + "range": { + "start": 42213, + "end": 42215 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "any.handle().eq(&_t3.handle_a1())", + "semantic_text": "any == _t3.a1", + "referenced_vars": [ + "_t3", + "any" + ], + "range": { + "start": 42233, + "end": 42235 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "x.handle().eq(&_t3.handle())", + "semantic_text": "x == _t3", + "referenced_vars": [ + "_t3", + "x" + ], + "range": { + "start": 42253, + "end": 42255 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@200107:200177", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_body_contains_operand(pat.f, ctx.devalue(pat.i), pat.x)", + "semantic_text": null, + "referenced_pat_vars": [ + "f", + "i", + "x" + ], + "referenced_action_vars": [], + "range": { + "start": 200107, + "end": 200177 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0036", + "premises": [ + { + "target_id": "any", + "label": "any: ", + "plain_source": "upright(\"any\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"any\") $]" + }, + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_rel1", + "label": "_rel1: EcxBody_contains_Body", + "plain_source": "upright(\"_rel1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_rel1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxTheta", + "plain_source": "upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxVecOperand_get", + "plain_source": "upright(\"_t3\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]" + } + ], + "side_conditions": [ + "i == upright(\"_rel1.a1\")", + "upright(\"any\") == upright(\"_t3.a1\")", + "x == upright(\"_t3\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, x)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ x $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, x)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ x $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"any\") \\ i \\ upright(\"_rel1\") \\ upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\")) \\ upright(\"_t3\"), upright(\"EcxBodyContainsOperand\")(f, i, x)) quad upright(\"if\") quad i == upright(\"_rel1.a1\") \\ upright(\"any\") == upright(\"_t3.a1\") \\ x == upright(\"_t3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"any\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_rel1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $], upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ x $])) quad upright(\"if\") quad i == upright(\"_rel1.a1\") \\ upright(\"any\") == upright(\"_t3.a1\") \\ x == upright(\"_t3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6739_5_MyTxEggccExtraction_add_rule__r0037__1624da3cdf158ee0", + "display_name": "r0037", + "rule_name": "r0037", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 200191, + "line": 6739, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 200191, + "end": 200359 + }, + "pattern_range": { + "start": 200236, + "end": 200247 + }, + "action_range": { + "start": 200249, + "end": 200358 + } + }, + "nodes": [ + { + "id": "any", + "kind": "query", + "dsl_type": "", + "label": "any: ", + "range": { + "start": 42543, + "end": 42592 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "f: EcxBody", + "range": { + "start": 42597, + "end": 42627 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 42632, + "end": 42677 + }, + "inputs": [] + }, + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "vec: EcxVecOperand", + "range": { + "start": 42682, + "end": 42720 + }, + "inputs": [] + }, + { + "id": "x", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "x: EcxOperand", + "range": { + "start": 42725, + "end": 42758 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxOperandGroup", + "label": "_t2: EcxOperandGroup", + "range": { + "start": 42763, + "end": 42802 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "EcxBody_contains_Body", + "label": "_rel1: EcxBody_contains_Body", + "range": { + "start": 42807, + "end": 42858 + }, + "inputs": [ + "f", + "_t2" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxVecOperand_get", + "label": "_t3: EcxVecOperand_get", + "range": { + "start": 42863, + "end": 42904 + }, + "inputs": [ + "vec" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "f", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "_t2", + "kind": "operand", + "index": 1 + }, + { + "from": "_t3", + "to": "vec", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "any", + "f", + "i", + "vec", + "x", + "_rel1", + "_t2", + "_t3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_rel1.handle_a1())", + "semantic_text": "i == _rel1.a1", + "referenced_vars": [ + "_rel1", + "i" + ], + "range": { + "start": 43113, + "end": 43115 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "any.handle().eq(&_t3.handle_a1())", + "semantic_text": "any == _t3.a1", + "referenced_vars": [ + "_t3", + "any" + ], + "range": { + "start": 43133, + "end": 43135 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "x.handle().eq(&_t3.handle())", + "semantic_text": "x == _t3", + "referenced_vars": [ + "_t3", + "x" + ], + "range": { + "start": 43153, + "end": 43155 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@200281:200351", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_body_contains_operand(pat.f, ctx.devalue(pat.i), pat.x)", + "semantic_text": null, + "referenced_pat_vars": [ + "f", + "i", + "x" + ], + "referenced_action_vars": [], + "range": { + "start": 200281, + "end": 200351 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0037", + "premises": [ + { + "target_id": "any", + "label": "any: ", + "plain_source": "upright(\"any\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"any\") $]" + }, + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_rel1", + "label": "_rel1: EcxBody_contains_Body", + "plain_source": "upright(\"_rel1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_rel1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxOperandGroup", + "plain_source": "upright(\"OperandGroup\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"OperandGroup\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxVecOperand_get", + "plain_source": "upright(\"_t3\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]" + } + ], + "side_conditions": [ + "i == upright(\"_rel1.a1\")", + "upright(\"any\") == upright(\"_t3.a1\")", + "x == upright(\"_t3\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, x)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ x $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, x)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ x $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"any\") \\ i \\ upright(\"_rel1\") \\ upright(\"OperandGroup\")(upright(\"vec\")) \\ upright(\"_t3\"), upright(\"EcxBodyContainsOperand\")(f, i, x)) quad upright(\"if\") quad i == upright(\"_rel1.a1\") \\ upright(\"any\") == upright(\"_t3.a1\") \\ x == upright(\"_t3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"any\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_rel1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"OperandGroup\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $], upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ x $])) quad upright(\"if\") quad i == upright(\"_rel1.a1\") \\ upright(\"any\") == upright(\"_t3.a1\") \\ x == upright(\"_t3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6742_5_MyTxEggccExtraction_add_rule__r0038__0a59f1366bb4cc37", + "display_name": "r0038", + "rule_name": "r0038", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 200365, + "line": 6742, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 200365, + "end": 200533 + }, + "pattern_range": { + "start": 200410, + "end": 200421 + }, + "action_range": { + "start": 200423, + "end": 200532 + } + }, + "nodes": [ + { + "id": "any", + "kind": "query", + "dsl_type": "", + "label": "any: ", + "range": { + "start": 43494, + "end": 43543 + }, + "inputs": [] + }, + { + "id": "args", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "args: EcxVecOperand", + "range": { + "start": 43548, + "end": 43587 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "f: EcxBody", + "range": { + "start": 43592, + "end": 43622 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 43627, + "end": 43672 + }, + "inputs": [] + }, + { + "id": "n_outs", + "kind": "query", + "dsl_type": "", + "label": "n_outs: ", + "range": { + "start": 43677, + "end": 43732 + }, + "inputs": [] + }, + { + "id": "name", + "kind": "query", + "dsl_type": "", + "label": "name: ", + "range": { + "start": 43737, + "end": 43791 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxOptionType", + "label": "ty: EcxOptionType", + "range": { + "start": 43796, + "end": 43833 + }, + "inputs": [] + }, + { + "id": "x", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "x: EcxOperand", + "range": { + "start": 43838, + "end": 43871 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxCall", + "label": "_t2: EcxCall", + "range": { + "start": 43876, + "end": 43913 + }, + "inputs": [ + "ty", + "args" + ] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "EcxBody_contains_Expr", + "label": "_rel1: EcxBody_contains_Expr", + "range": { + "start": 43918, + "end": 43969 + }, + "inputs": [ + "f", + "_t2" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxVecOperand_get", + "label": "_t3: EcxVecOperand_get", + "range": { + "start": 43974, + "end": 44016 + }, + "inputs": [ + "args" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "args", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel1", + "to": "f", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "_t2", + "kind": "operand", + "index": 1 + }, + { + "from": "_t3", + "to": "args", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "any", + "args", + "f", + "i", + "n_outs", + "name", + "ty", + "x", + "_rel1", + "_t2", + "_t3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "name.handle().eq(&_t2.handle_a1())", + "semantic_text": "name == _t2.a1", + "referenced_vars": [ + "_t2", + "name" + ], + "range": { + "start": 44344, + "end": 44346 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "n_outs.handle().eq(&_t2.handle_a3())", + "semantic_text": "n_outs == _t2.a3", + "referenced_vars": [ + "_t2", + "n_outs" + ], + "range": { + "start": 44364, + "end": 44366 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "i.handle().eq(&_rel1.handle_a1())", + "semantic_text": "i == _rel1.a1", + "referenced_vars": [ + "_rel1", + "i" + ], + "range": { + "start": 44384, + "end": 44386 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "any.handle().eq(&_t3.handle_a1())", + "semantic_text": "any == _t3.a1", + "referenced_vars": [ + "_t3", + "any" + ], + "range": { + "start": 44404, + "end": 44406 + } + }, + { + "id": "constraint_4", + "source_text": "c4", + "resolved_text": "x.handle().eq(&_t3.handle())", + "semantic_text": "x == _t3", + "referenced_vars": [ + "_t3", + "x" + ], + "range": { + "start": 44424, + "end": 44426 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@200455:200525", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_body_contains_operand(pat.f, ctx.devalue(pat.i), pat.x)", + "semantic_text": null, + "referenced_pat_vars": [ + "f", + "i", + "x" + ], + "referenced_action_vars": [], + "range": { + "start": 200455, + "end": 200525 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0038", + "premises": [ + { + "target_id": "any", + "label": "any: ", + "plain_source": "upright(\"any\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"any\") $]" + }, + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "n_outs", + "label": "n_outs: ", + "plain_source": "upright(\"n_outs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"n_outs\") $]" + }, + { + "target_id": "name", + "label": "name: ", + "plain_source": "upright(\"name\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"name\") $]" + }, + { + "target_id": "_rel1", + "label": "_rel1: EcxBody_contains_Expr", + "plain_source": "upright(\"EcxBody_contains_Expr\")(f, upright(\"_t2\"))", + "colored_source": "upright(\"EcxBody_contains_Expr\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $])" + }, + { + "target_id": "_t2", + "label": "_t2: EcxCall", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxVecOperand_get", + "plain_source": "upright(\"_t3\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]" + } + ], + "side_conditions": [ + "upright(\"name\") == upright(\"_t2.a1\")", + "upright(\"n_outs\") == upright(\"_t2.a3\")", + "i == upright(\"_rel1.a1\")", + "upright(\"any\") == upright(\"_t3.a1\")", + "x == upright(\"_t3\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, x)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ x $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, x)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ x $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"any\") \\ i \\ upright(\"n_outs\") \\ upright(\"name\") \\ upright(\"EcxBody_contains_Expr\")(f, upright(\"_t2\")) \\ upright(\"_t2\") \\ upright(\"_t3\"), upright(\"EcxBodyContainsOperand\")(f, i, x)) quad upright(\"if\") quad upright(\"name\") == upright(\"_t2.a1\") \\ upright(\"n_outs\") == upright(\"_t2.a3\") \\ i == upright(\"_rel1.a1\") \\ upright(\"any\") == upright(\"_t3.a1\") \\ x == upright(\"_t3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"any\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"n_outs\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"name\") $] \\ upright(\"EcxBody_contains_Expr\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $], upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ x $])) quad upright(\"if\") quad upright(\"name\") == upright(\"_t2.a1\") \\ upright(\"n_outs\") == upright(\"_t2.a3\") \\ i == upright(\"_rel1.a1\") \\ upright(\"any\") == upright(\"_t3.a1\") \\ x == upright(\"_t3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6745_5_MyTxEggccExtraction_add_rule__r0039__e419ec10d13e4461", + "display_name": "r0039", + "rule_name": "r0039", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 200539, + "line": 6745, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 200539, + "end": 200800 + }, + "pattern_range": { + "start": 200584, + "end": 200595 + }, + "action_range": { + "start": 200597, + "end": 200799 + } + }, + "nodes": [ + { + "id": "e1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e1: EcxOperand", + "range": { + "start": 44662, + "end": 44696 + }, + "inputs": [] + }, + { + "id": "e2", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e2: EcxOperand", + "range": { + "start": 44701, + "end": 44735 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "f: EcxBody", + "range": { + "start": 44740, + "end": 44770 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 44775, + "end": 44820 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxPRINT", + "label": "_t2: EcxPRINT", + "range": { + "start": 44825, + "end": 44861 + }, + "inputs": [ + "e1", + "e2" + ] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "EcxBody_contains_Expr", + "label": "_rel1: EcxBody_contains_Expr", + "range": { + "start": 44866, + "end": 44917 + }, + "inputs": [ + "f", + "_t2" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "e1", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "e2", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel1", + "to": "f", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "_t2", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "e1", + "e2", + "f", + "i", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_rel1.handle_a1())", + "semantic_text": "i == _rel1.a1", + "referenced_vars": [ + "_rel1", + "i" + ], + "range": { + "start": 45016, + "end": 45018 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@200629:200700", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_body_contains_operand(pat.f, ctx.devalue(pat.i), pat.e1)", + "semantic_text": null, + "referenced_pat_vars": [ + "e1", + "f", + "i" + ], + "referenced_action_vars": [], + "range": { + "start": 200629, + "end": 200700 + } + }, + { + "id": "effect_1", + "effect_id": "effect@200721:200792", + "bound_var": "rel2", + "source_text": "ctx.insert_ecx_body_contains_operand(pat.f, ctx.devalue(pat.i), pat.e2)", + "semantic_text": null, + "referenced_pat_vars": [ + "e2", + "f", + "i" + ], + "referenced_action_vars": [], + "range": { + "start": 200721, + "end": 200792 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0039", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_rel1", + "label": "_rel1: EcxBody_contains_Expr", + "plain_source": "upright(\"_rel1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_rel1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxPRINT", + "plain_source": "upright(\"PRINT\")(e_1, e_2)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PRINT\")(#text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $]" + } + ], + "side_conditions": [ + "i == upright(\"_rel1.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, e_1)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $])" + }, + { + "target_id": "effect:effect_1", + "label": "rel2", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, e_2)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, e_1)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $])" + } + }, + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "rel2", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, e_2)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $])" + } + } + ], + "formula_source": { + "plain": "frac(i \\ upright(\"_rel1\") \\ upright(\"PRINT\")(e_1, e_2), upright(\"EcxBodyContainsOperand\")(f, i, e_1) \\ upright(\"EcxBodyContainsOperand\")(f, i, e_2)) quad upright(\"if\") quad i == upright(\"_rel1.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_rel1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PRINT\")(#text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $], upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $]) \\ upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $])) quad upright(\"if\") quad i == upright(\"_rel1.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6749_5_MyTxEggccExtraction_add_rule__r0040__636031d369d94a95", + "display_name": "r0040", + "rule_name": "r0040", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 200806, + "line": 6749, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 200806, + "end": 201067 + }, + "pattern_range": { + "start": 200851, + "end": 200862 + }, + "action_range": { + "start": 200864, + "end": 201066 + } + }, + "nodes": [ + { + "id": "e1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e1: EcxOperand", + "range": { + "start": 45275, + "end": 45309 + }, + "inputs": [] + }, + { + "id": "e2", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e2: EcxOperand", + "range": { + "start": 45314, + "end": 45348 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "f: EcxBody", + "range": { + "start": 45353, + "end": 45383 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 45388, + "end": 45433 + }, + "inputs": [] + }, + { + "id": "kw_type", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "kw_type: EcxType", + "range": { + "start": 45438, + "end": 45474 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxbadd", + "label": "_t2: Ecxbadd", + "range": { + "start": 45479, + "end": 45524 + }, + "inputs": [ + "kw_type", + "e1", + "e2" + ] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "EcxBody_contains_Expr", + "label": "_rel1: EcxBody_contains_Expr", + "range": { + "start": 45529, + "end": 45580 + }, + "inputs": [ + "f", + "_t2" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "kw_type", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "e1", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "e2", + "kind": "operand", + "index": 2 + }, + { + "from": "_rel1", + "to": "f", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "_t2", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "e1", + "e2", + "f", + "i", + "kw_type", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_rel1.handle_a1())", + "semantic_text": "i == _rel1.a1", + "referenced_vars": [ + "_rel1", + "i" + ], + "range": { + "start": 45688, + "end": 45690 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@200896:200967", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_body_contains_operand(pat.f, ctx.devalue(pat.i), pat.e1)", + "semantic_text": null, + "referenced_pat_vars": [ + "e1", + "f", + "i" + ], + "referenced_action_vars": [], + "range": { + "start": 200896, + "end": 200967 + } + }, + { + "id": "effect_1", + "effect_id": "effect@200988:201059", + "bound_var": "rel2", + "source_text": "ctx.insert_ecx_body_contains_operand(pat.f, ctx.devalue(pat.i), pat.e2)", + "semantic_text": null, + "referenced_pat_vars": [ + "e2", + "f", + "i" + ], + "referenced_action_vars": [], + "range": { + "start": 200988, + "end": 201059 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0040", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_rel1", + "label": "_rel1: EcxBody_contains_Expr", + "plain_source": "upright(\"_rel1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_rel1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxbadd", + "plain_source": "upright(\"badd\")(upright(\"kw_type\"), e_1, e_2)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $]" + } + ], + "side_conditions": [ + "i == upright(\"_rel1.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, e_1)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $])" + }, + { + "target_id": "effect:effect_1", + "label": "rel2", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, e_2)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, e_1)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $])" + } + }, + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "rel2", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, e_2)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $])" + } + } + ], + "formula_source": { + "plain": "frac(i \\ upright(\"_rel1\") \\ upright(\"badd\")(upright(\"kw_type\"), e_1, e_2), upright(\"EcxBodyContainsOperand\")(f, i, e_1) \\ upright(\"EcxBodyContainsOperand\")(f, i, e_2)) quad upright(\"if\") quad i == upright(\"_rel1.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_rel1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $], upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $]) \\ upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $])) quad upright(\"if\") quad i == upright(\"_rel1.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6753_5_MyTxEggccExtraction_add_rule__r0041__71ff1e4b3b190c0d", + "display_name": "r0041", + "rule_name": "r0041", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 201073, + "line": 6753, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 201073, + "end": 201334 + }, + "pattern_range": { + "start": 201118, + "end": 201129 + }, + "action_range": { + "start": 201131, + "end": 201333 + } + }, + "nodes": [ + { + "id": "e1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e1: EcxOperand", + "range": { + "start": 45947, + "end": 45981 + }, + "inputs": [] + }, + { + "id": "e2", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e2: EcxOperand", + "range": { + "start": 45986, + "end": 46020 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "f: EcxBody", + "range": { + "start": 46025, + "end": 46055 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 46060, + "end": 46105 + }, + "inputs": [] + }, + { + "id": "kw_type", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "kw_type: EcxType", + "range": { + "start": 46110, + "end": 46146 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxbsub", + "label": "_t2: Ecxbsub", + "range": { + "start": 46151, + "end": 46196 + }, + "inputs": [ + "kw_type", + "e1", + "e2" + ] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "EcxBody_contains_Expr", + "label": "_rel1: EcxBody_contains_Expr", + "range": { + "start": 46201, + "end": 46252 + }, + "inputs": [ + "f", + "_t2" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "kw_type", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "e1", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "e2", + "kind": "operand", + "index": 2 + }, + { + "from": "_rel1", + "to": "f", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "_t2", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "e1", + "e2", + "f", + "i", + "kw_type", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_rel1.handle_a1())", + "semantic_text": "i == _rel1.a1", + "referenced_vars": [ + "_rel1", + "i" + ], + "range": { + "start": 46360, + "end": 46362 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@201163:201234", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_body_contains_operand(pat.f, ctx.devalue(pat.i), pat.e1)", + "semantic_text": null, + "referenced_pat_vars": [ + "e1", + "f", + "i" + ], + "referenced_action_vars": [], + "range": { + "start": 201163, + "end": 201234 + } + }, + { + "id": "effect_1", + "effect_id": "effect@201255:201326", + "bound_var": "rel2", + "source_text": "ctx.insert_ecx_body_contains_operand(pat.f, ctx.devalue(pat.i), pat.e2)", + "semantic_text": null, + "referenced_pat_vars": [ + "e2", + "f", + "i" + ], + "referenced_action_vars": [], + "range": { + "start": 201255, + "end": 201326 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0041", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_rel1", + "label": "_rel1: EcxBody_contains_Expr", + "plain_source": "upright(\"_rel1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_rel1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxbsub", + "plain_source": "upright(\"bsub\")(upright(\"kw_type\"), e_1, e_2)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $]" + } + ], + "side_conditions": [ + "i == upright(\"_rel1.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, e_1)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $])" + }, + { + "target_id": "effect:effect_1", + "label": "rel2", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, e_2)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, e_1)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $])" + } + }, + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "rel2", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, e_2)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $])" + } + } + ], + "formula_source": { + "plain": "frac(i \\ upright(\"_rel1\") \\ upright(\"bsub\")(upright(\"kw_type\"), e_1, e_2), upright(\"EcxBodyContainsOperand\")(f, i, e_1) \\ upright(\"EcxBodyContainsOperand\")(f, i, e_2)) quad upright(\"if\") quad i == upright(\"_rel1.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_rel1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $], upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $]) \\ upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $])) quad upright(\"if\") quad i == upright(\"_rel1.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6757_5_MyTxEggccExtraction_add_rule__r0042__10fc1a7101e69870", + "display_name": "r0042", + "rule_name": "r0042", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 201340, + "line": 6757, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 201340, + "end": 201601 + }, + "pattern_range": { + "start": 201385, + "end": 201396 + }, + "action_range": { + "start": 201398, + "end": 201600 + } + }, + "nodes": [ + { + "id": "e1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e1: EcxOperand", + "range": { + "start": 46619, + "end": 46653 + }, + "inputs": [] + }, + { + "id": "e2", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e2: EcxOperand", + "range": { + "start": 46658, + "end": 46692 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "f: EcxBody", + "range": { + "start": 46697, + "end": 46727 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 46732, + "end": 46777 + }, + "inputs": [] + }, + { + "id": "kw_type", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "kw_type: EcxType", + "range": { + "start": 46782, + "end": 46818 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxbmul", + "label": "_t2: Ecxbmul", + "range": { + "start": 46823, + "end": 46868 + }, + "inputs": [ + "kw_type", + "e1", + "e2" + ] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "EcxBody_contains_Expr", + "label": "_rel1: EcxBody_contains_Expr", + "range": { + "start": 46873, + "end": 46924 + }, + "inputs": [ + "f", + "_t2" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "kw_type", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "e1", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "e2", + "kind": "operand", + "index": 2 + }, + { + "from": "_rel1", + "to": "f", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "_t2", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "e1", + "e2", + "f", + "i", + "kw_type", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_rel1.handle_a1())", + "semantic_text": "i == _rel1.a1", + "referenced_vars": [ + "_rel1", + "i" + ], + "range": { + "start": 47032, + "end": 47034 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@201430:201501", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_body_contains_operand(pat.f, ctx.devalue(pat.i), pat.e1)", + "semantic_text": null, + "referenced_pat_vars": [ + "e1", + "f", + "i" + ], + "referenced_action_vars": [], + "range": { + "start": 201430, + "end": 201501 + } + }, + { + "id": "effect_1", + "effect_id": "effect@201522:201593", + "bound_var": "rel2", + "source_text": "ctx.insert_ecx_body_contains_operand(pat.f, ctx.devalue(pat.i), pat.e2)", + "semantic_text": null, + "referenced_pat_vars": [ + "e2", + "f", + "i" + ], + "referenced_action_vars": [], + "range": { + "start": 201522, + "end": 201593 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0042", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_rel1", + "label": "_rel1: EcxBody_contains_Expr", + "plain_source": "upright(\"_rel1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_rel1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxbmul", + "plain_source": "upright(\"bmul\")(upright(\"kw_type\"), e_1, e_2)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $]" + } + ], + "side_conditions": [ + "i == upright(\"_rel1.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, e_1)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $])" + }, + { + "target_id": "effect:effect_1", + "label": "rel2", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, e_2)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, e_1)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $])" + } + }, + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "rel2", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, e_2)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $])" + } + } + ], + "formula_source": { + "plain": "frac(i \\ upright(\"_rel1\") \\ upright(\"bmul\")(upright(\"kw_type\"), e_1, e_2), upright(\"EcxBodyContainsOperand\")(f, i, e_1) \\ upright(\"EcxBodyContainsOperand\")(f, i, e_2)) quad upright(\"if\") quad i == upright(\"_rel1.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_rel1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $], upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $]) \\ upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $])) quad upright(\"if\") quad i == upright(\"_rel1.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6761_5_MyTxEggccExtraction_add_rule__r0043__4c1a05b89125d25e", + "display_name": "r0043", + "rule_name": "r0043", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 201607, + "line": 6761, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 201607, + "end": 201868 + }, + "pattern_range": { + "start": 201652, + "end": 201663 + }, + "action_range": { + "start": 201665, + "end": 201867 + } + }, + "nodes": [ + { + "id": "e1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e1: EcxOperand", + "range": { + "start": 47291, + "end": 47325 + }, + "inputs": [] + }, + { + "id": "e2", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e2: EcxOperand", + "range": { + "start": 47330, + "end": 47364 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "f: EcxBody", + "range": { + "start": 47369, + "end": 47399 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 47404, + "end": 47449 + }, + "inputs": [] + }, + { + "id": "kw_type", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "kw_type: EcxType", + "range": { + "start": 47454, + "end": 47490 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxbdiv", + "label": "_t2: Ecxbdiv", + "range": { + "start": 47495, + "end": 47540 + }, + "inputs": [ + "kw_type", + "e1", + "e2" + ] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "EcxBody_contains_Expr", + "label": "_rel1: EcxBody_contains_Expr", + "range": { + "start": 47545, + "end": 47596 + }, + "inputs": [ + "f", + "_t2" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "kw_type", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "e1", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "e2", + "kind": "operand", + "index": 2 + }, + { + "from": "_rel1", + "to": "f", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "_t2", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "e1", + "e2", + "f", + "i", + "kw_type", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_rel1.handle_a1())", + "semantic_text": "i == _rel1.a1", + "referenced_vars": [ + "_rel1", + "i" + ], + "range": { + "start": 47704, + "end": 47706 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@201697:201768", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_body_contains_operand(pat.f, ctx.devalue(pat.i), pat.e1)", + "semantic_text": null, + "referenced_pat_vars": [ + "e1", + "f", + "i" + ], + "referenced_action_vars": [], + "range": { + "start": 201697, + "end": 201768 + } + }, + { + "id": "effect_1", + "effect_id": "effect@201789:201860", + "bound_var": "rel2", + "source_text": "ctx.insert_ecx_body_contains_operand(pat.f, ctx.devalue(pat.i), pat.e2)", + "semantic_text": null, + "referenced_pat_vars": [ + "e2", + "f", + "i" + ], + "referenced_action_vars": [], + "range": { + "start": 201789, + "end": 201860 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0043", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_rel1", + "label": "_rel1: EcxBody_contains_Expr", + "plain_source": "upright(\"_rel1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_rel1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxbdiv", + "plain_source": "upright(\"bdiv\")(upright(\"kw_type\"), e_1, e_2)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $]" + } + ], + "side_conditions": [ + "i == upright(\"_rel1.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, e_1)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $])" + }, + { + "target_id": "effect:effect_1", + "label": "rel2", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, e_2)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, e_1)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $])" + } + }, + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "rel2", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, e_2)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $])" + } + } + ], + "formula_source": { + "plain": "frac(i \\ upright(\"_rel1\") \\ upright(\"bdiv\")(upright(\"kw_type\"), e_1, e_2), upright(\"EcxBodyContainsOperand\")(f, i, e_1) \\ upright(\"EcxBodyContainsOperand\")(f, i, e_2)) quad upright(\"if\") quad i == upright(\"_rel1.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_rel1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $], upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $]) \\ upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $])) quad upright(\"if\") quad i == upright(\"_rel1.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6765_5_MyTxEggccExtraction_add_rule__r0044__bd57060584a3e22b", + "display_name": "r0044", + "rule_name": "r0044", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 201874, + "line": 6765, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 201874, + "end": 202135 + }, + "pattern_range": { + "start": 201919, + "end": 201930 + }, + "action_range": { + "start": 201932, + "end": 202134 + } + }, + "nodes": [ + { + "id": "e1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e1: EcxOperand", + "range": { + "start": 47962, + "end": 47996 + }, + "inputs": [] + }, + { + "id": "e2", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e2: EcxOperand", + "range": { + "start": 48001, + "end": 48035 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "f: EcxBody", + "range": { + "start": 48040, + "end": 48070 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 48075, + "end": 48120 + }, + "inputs": [] + }, + { + "id": "kw_type", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "kw_type: EcxType", + "range": { + "start": 48125, + "end": 48161 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxblt", + "label": "_t2: Ecxblt", + "range": { + "start": 48166, + "end": 48210 + }, + "inputs": [ + "kw_type", + "e1", + "e2" + ] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "EcxBody_contains_Expr", + "label": "_rel1: EcxBody_contains_Expr", + "range": { + "start": 48215, + "end": 48266 + }, + "inputs": [ + "f", + "_t2" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "kw_type", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "e1", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "e2", + "kind": "operand", + "index": 2 + }, + { + "from": "_rel1", + "to": "f", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "_t2", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "e1", + "e2", + "f", + "i", + "kw_type", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_rel1.handle_a1())", + "semantic_text": "i == _rel1.a1", + "referenced_vars": [ + "_rel1", + "i" + ], + "range": { + "start": 48374, + "end": 48376 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@201964:202035", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_body_contains_operand(pat.f, ctx.devalue(pat.i), pat.e1)", + "semantic_text": null, + "referenced_pat_vars": [ + "e1", + "f", + "i" + ], + "referenced_action_vars": [], + "range": { + "start": 201964, + "end": 202035 + } + }, + { + "id": "effect_1", + "effect_id": "effect@202056:202127", + "bound_var": "rel2", + "source_text": "ctx.insert_ecx_body_contains_operand(pat.f, ctx.devalue(pat.i), pat.e2)", + "semantic_text": null, + "referenced_pat_vars": [ + "e2", + "f", + "i" + ], + "referenced_action_vars": [], + "range": { + "start": 202056, + "end": 202127 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0044", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_rel1", + "label": "_rel1: EcxBody_contains_Expr", + "plain_source": "upright(\"_rel1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_rel1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxblt", + "plain_source": "upright(\"blt\")(upright(\"kw_type\"), e_1, e_2)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $]" + } + ], + "side_conditions": [ + "i == upright(\"_rel1.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, e_1)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $])" + }, + { + "target_id": "effect:effect_1", + "label": "rel2", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, e_2)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, e_1)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $])" + } + }, + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "rel2", + "plain_source": "upright(\"EcxBodyContainsOperand\")(f, i, e_2)", + "colored_source": "upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $])" + } + } + ], + "formula_source": { + "plain": "frac(i \\ upright(\"_rel1\") \\ upright(\"blt\")(upright(\"kw_type\"), e_1, e_2), upright(\"EcxBodyContainsOperand\")(f, i, e_1) \\ upright(\"EcxBodyContainsOperand\")(f, i, e_2)) quad upright(\"if\") quad i == upright(\"_rel1.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_rel1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $], upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $]) \\ upright(\"EcxBodyContainsOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $])) quad upright(\"if\") quad i == upright(\"_rel1.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6769_5_MyTxEggccExtraction_add_rule__r0045__a2d14a1384051dac", + "display_name": "r0045", + "rule_name": "r0045", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 202141, + "line": 6769, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 202141, + "end": 202309 + }, + "pattern_range": { + "start": 202186, + "end": 202197 + }, + "action_range": { + "start": 202199, + "end": 202308 + } + }, + "nodes": [ + { + "id": "body", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "body: EcxBody", + "range": { + "start": 48593, + "end": 48626 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "f: EcxBody", + "range": { + "start": 48631, + "end": 48661 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 48666, + "end": 48711 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t2: EcxNode", + "range": { + "start": 48716, + "end": 48748 + }, + "inputs": [ + "body" + ] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "EcxBody_contains_Operand", + "label": "_rel1: EcxBody_contains_Operand", + "range": { + "start": 48753, + "end": 48807 + }, + "inputs": [ + "f", + "_t2" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "body", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "f", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "_t2", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "body", + "f", + "i", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_rel1.handle_a1())", + "semantic_text": "i == _rel1.a1", + "referenced_vars": [ + "_rel1", + "i" + ], + "range": { + "start": 48904, + "end": 48906 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@202231:202301", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_body_contains_body(pat.f, ctx.devalue(pat.i), pat.body)", + "semantic_text": null, + "referenced_pat_vars": [ + "body", + "f", + "i" + ], + "referenced_action_vars": [], + "range": { + "start": 202231, + "end": 202301 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0045", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_rel1", + "label": "_rel1: EcxBody_contains_Operand", + "plain_source": "upright(\"_rel1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_rel1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxNode", + "plain_source": "upright(\"Node\")(upright(\"body\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $]) $]" + } + ], + "side_conditions": [ + "i == upright(\"_rel1.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsBody\")(f, i, upright(\"body\"))", + "colored_source": "upright(\"EcxBodyContainsBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsBody\")(f, i, upright(\"body\"))", + "colored_source": "upright(\"EcxBodyContainsBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $])" + } + } + ], + "formula_source": { + "plain": "frac(i \\ upright(\"_rel1\") \\ upright(\"Node\")(upright(\"body\")), upright(\"EcxBodyContainsBody\")(f, i, upright(\"body\"))) quad upright(\"if\") quad i == upright(\"_rel1.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_rel1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $]) $], upright(\"EcxBodyContainsBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $])) quad upright(\"if\") quad i == upright(\"_rel1.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6772_5_MyTxEggccExtraction_add_rule__r0046__931896ed070a8241", + "display_name": "r0046", + "rule_name": "r0046", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 202315, + "line": 6772, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 202315, + "end": 202483 + }, + "pattern_range": { + "start": 202360, + "end": 202371 + }, + "action_range": { + "start": 202373, + "end": 202482 + } + }, + "nodes": [ + { + "id": "body", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "body: EcxBody", + "range": { + "start": 49126, + "end": 49159 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "f: EcxBody", + "range": { + "start": 49164, + "end": 49194 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 49199, + "end": 49244 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxProject", + "label": "_t2: EcxProject", + "range": { + "start": 49249, + "end": 49284 + }, + "inputs": [ + "body" + ] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "EcxBody_contains_Operand", + "label": "_rel1: EcxBody_contains_Operand", + "range": { + "start": 49289, + "end": 49343 + }, + "inputs": [ + "f", + "_t2" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "body", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "f", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "_t2", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "body", + "f", + "i", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_t2.handle_a0())", + "semantic_text": "i == _t2.a0", + "referenced_vars": [ + "_t2", + "i" + ], + "range": { + "start": 49486, + "end": 49488 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "i.handle().eq(&_rel1.handle_a1())", + "semantic_text": "i == _rel1.a1", + "referenced_vars": [ + "_rel1", + "i" + ], + "range": { + "start": 49497, + "end": 49499 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@202405:202475", + "bound_var": "rel1", + "source_text": "ctx.insert_ecx_body_contains_body(pat.f, ctx.devalue(pat.i), pat.body)", + "semantic_text": null, + "referenced_pat_vars": [ + "body", + "f", + "i" + ], + "referenced_action_vars": [], + "range": { + "start": 202405, + "end": 202475 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0046", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_rel1", + "label": "_rel1: EcxBody_contains_Operand", + "plain_source": "upright(\"EcxBody_contains_Operand\")(f, upright(\"_t2\"))", + "colored_source": "upright(\"EcxBody_contains_Operand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $])" + }, + { + "target_id": "_t2", + "label": "_t2: EcxProject", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + } + ], + "side_conditions": [ + "i == upright(\"_t2.a0\")", + "i == upright(\"_rel1.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsBody\")(f, i, upright(\"body\"))", + "colored_source": "upright(\"EcxBodyContainsBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "rel1", + "plain_source": "upright(\"EcxBodyContainsBody\")(f, i, upright(\"body\"))", + "colored_source": "upright(\"EcxBodyContainsBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $])" + } + } + ], + "formula_source": { + "plain": "frac(i \\ upright(\"EcxBody_contains_Operand\")(f, upright(\"_t2\")) \\ upright(\"_t2\"), upright(\"EcxBodyContainsBody\")(f, i, upright(\"body\"))) quad upright(\"if\") quad i == upright(\"_t2.a0\") \\ i == upright(\"_rel1.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ upright(\"EcxBody_contains_Operand\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], upright(\"EcxBodyContainsBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $])) quad upright(\"if\") quad i == upright(\"_t2.a0\") \\ i == upright(\"_rel1.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6775_5_MyTxEggccExtraction_add_rule__r0047__f1749f2b0344f733", + "display_name": "r0047", + "rule_name": "r0047", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 202489, + "line": 6775, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 202489, + "end": 202673 + }, + "pattern_range": { + "start": 202535, + "end": 202546 + }, + "action_range": { + "start": 202548, + "end": 202672 + } + }, + "nodes": [ + { + "id": "above", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "above: EcxBody", + "range": { + "start": 49791, + "end": 49825 + }, + "inputs": [] + }, + { + "id": "from", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "from: EcxOperand", + "range": { + "start": 49830, + "end": 49866 + }, + "inputs": [] + }, + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 49871, + "end": 49912 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "outputs: EcxVecOperand", + "range": { + "start": 49917, + "end": 49959 + }, + "inputs": [] + }, + { + "id": "to", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "to: EcxOperand", + "range": { + "start": 49964, + "end": 49998 + }, + "inputs": [] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "Ecxcan_subst_Operand_beneath", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "range": { + "start": 50003, + "end": 50071 + }, + "inputs": [ + "above", + "from", + "to" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxTheta", + "label": "_t2: EcxTheta", + "range": { + "start": 50076, + "end": 50128 + }, + "inputs": [ + "from", + "inputs", + "outputs" + ] + } + ], + "edges": [ + { + "from": "_rel1", + "to": "above", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel1", + "to": "to", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "from", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "outputs", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "above", + "from", + "inputs", + "outputs", + "to", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "above.handle().eq(&_t2.handle())", + "semantic_text": "above == _t2", + "referenced_vars": [ + "_t2", + "above" + ], + "range": { + "start": 50246, + "end": 50248 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@202578:202631", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_theta(pat.to, pat.inputs, pat.outputs)", + "semantic_text": null, + "referenced_pat_vars": [ + "inputs", + "outputs", + "to" + ], + "referenced_action_vars": [], + "range": { + "start": 202578, + "end": 202631 + } + }, + { + "id": "effect_1", + "effect_id": "effect@202641:202665", + "bound_var": null, + "source_text": "ctx.union(pat.above, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "above" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 202641, + "end": 202665 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0047", + "premises": [ + { + "target_id": "_rel1", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "plain_source": "upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxTheta", + "plain_source": "upright(\"Theta\")(upright(\"from\"), upright(\"inputs\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + ], + "side_conditions": [ + "upright(\"above\") == upright(\"_t2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"Theta\")(upright(\"to\"), upright(\"inputs\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "above", + "label": "above: EcxBody", + "plain_source": "upright(\"above\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"Theta\")(upright(\"to\"), upright(\"inputs\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\")) \\ upright(\"Theta\")(upright(\"from\"), upright(\"inputs\"), upright(\"outputs\")), upright(\"above\") arrow.r.double upright(\"Theta\")(upright(\"to\"), upright(\"inputs\"), upright(\"outputs\"))) quad upright(\"if\") quad upright(\"above\") == upright(\"_t2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]) quad upright(\"if\") quad upright(\"above\") == upright(\"_t2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6779_5_MyTxEggccExtraction_add_rule__r0048__8d4f0055cf086a8e", + "display_name": "r0048", + "rule_name": "r0048", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 202679, + "line": 6779, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 202679, + "end": 202860 + }, + "pattern_range": { + "start": 202725, + "end": 202736 + }, + "action_range": { + "start": 202738, + "end": 202859 + } + }, + "nodes": [ + { + "id": "above", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "above: EcxBody", + "range": { + "start": 50543, + "end": 50577 + }, + "inputs": [] + }, + { + "id": "from", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "from: EcxVecOperand", + "range": { + "start": 50582, + "end": 50621 + }, + "inputs": [] + }, + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 50626, + "end": 50667 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 50672, + "end": 50708 + }, + "inputs": [] + }, + { + "id": "to", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "to: EcxVecOperand", + "range": { + "start": 50713, + "end": 50750 + }, + "inputs": [] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "Ecxcan_subst_VecOperand_beneath", + "label": "_rel1: Ecxcan_subst_VecOperand_beneath", + "range": { + "start": 50755, + "end": 50826 + }, + "inputs": [ + "above", + "from", + "to" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxTheta", + "label": "_t2: EcxTheta", + "range": { + "start": 50831, + "end": 50880 + }, + "inputs": [ + "pred", + "inputs", + "from" + ] + } + ], + "edges": [ + { + "from": "_rel1", + "to": "above", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel1", + "to": "to", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "from", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "above", + "from", + "inputs", + "pred", + "to", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "above.handle().eq(&_t2.handle())", + "semantic_text": "above == _t2", + "referenced_vars": [ + "_t2", + "above" + ], + "range": { + "start": 50995, + "end": 50997 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@202768:202818", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_theta(pat.pred, pat.inputs, pat.to)", + "semantic_text": null, + "referenced_pat_vars": [ + "inputs", + "pred", + "to" + ], + "referenced_action_vars": [], + "range": { + "start": 202768, + "end": 202818 + } + }, + { + "id": "effect_1", + "effect_id": "effect@202828:202852", + "bound_var": null, + "source_text": "ctx.union(pat.above, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "above" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 202828, + "end": 202852 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0048", + "premises": [ + { + "target_id": "_rel1", + "label": "_rel1: Ecxcan_subst_VecOperand_beneath", + "plain_source": "upright(\"can_subst_VecOperand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_VecOperand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxTheta", + "plain_source": "upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"from\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $]) $]" + } + ], + "side_conditions": [ + "upright(\"above\") == upright(\"_t2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "above", + "label": "above: EcxBody", + "plain_source": "upright(\"above\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"can_subst_VecOperand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\")) \\ upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"from\")), upright(\"above\") arrow.r.double upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"to\"))) quad upright(\"if\") quad upright(\"above\") == upright(\"_t2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_VecOperand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]) quad upright(\"if\") quad upright(\"above\") == upright(\"_t2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6783_5_MyTxEggccExtraction_add_rule__r0049__b966418a1af4a104", + "display_name": "r0049", + "rule_name": "r0049", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 202866, + "line": 6783, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 202866, + "end": 203060 + }, + "pattern_range": { + "start": 202912, + "end": 202923 + }, + "action_range": { + "start": 202925, + "end": 203059 + } + }, + "nodes": [ + { + "id": "above", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "above: EcxBody", + "range": { + "start": 51379, + "end": 51413 + }, + "inputs": [] + }, + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 51418, + "end": 51459 + }, + "inputs": [] + }, + { + "id": "outputs_from", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "outputs_from: EcxVecOperand", + "range": { + "start": 51464, + "end": 51511 + }, + "inputs": [] + }, + { + "id": "outputs_to", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "outputs_to: EcxVecOperand", + "range": { + "start": 51516, + "end": 51561 + }, + "inputs": [] + }, + { + "id": "pred_from", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred_from: EcxOperand", + "range": { + "start": 51566, + "end": 51607 + }, + "inputs": [] + }, + { + "id": "pred_to", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred_to: EcxOperand", + "range": { + "start": 51612, + "end": 51651 + }, + "inputs": [] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "Ecxcan_subst_Operand_beneath", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "range": { + "start": 51656, + "end": 51734 + }, + "inputs": [ + "above", + "pred_from", + "pred_to" + ] + }, + { + "id": "_rel2", + "kind": "query", + "dsl_type": "Ecxcan_subst_VecOperand_beneath", + "label": "_rel2: Ecxcan_subst_VecOperand_beneath", + "range": { + "start": 51739, + "end": 51826 + }, + "inputs": [ + "above", + "outputs_from", + "outputs_to" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxTheta", + "label": "_t3: EcxTheta", + "range": { + "start": 51831, + "end": 51893 + }, + "inputs": [ + "pred_from", + "inputs", + "outputs_from" + ] + } + ], + "edges": [ + { + "from": "_rel1", + "to": "above", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "pred_from", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel1", + "to": "pred_to", + "kind": "operand", + "index": 2 + }, + { + "from": "_rel2", + "to": "above", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel2", + "to": "outputs_from", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel2", + "to": "outputs_to", + "kind": "operand", + "index": 2 + }, + { + "from": "_t3", + "to": "pred_from", + "kind": "operand", + "index": 0 + }, + { + "from": "_t3", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t3", + "to": "outputs_from", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "above", + "inputs", + "outputs_from", + "outputs_to", + "pred_from", + "pred_to", + "_rel1", + "_rel2", + "_t3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "above.handle().eq(&_t3.handle())", + "semantic_text": "above == _t3", + "referenced_vars": [ + "_t3", + "above" + ], + "range": { + "start": 52129, + "end": 52131 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@202955:203018", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_theta(pat.pred_from, pat.inputs, pat.outputs_to)", + "semantic_text": null, + "referenced_pat_vars": [ + "inputs", + "outputs_to", + "pred_from" + ], + "referenced_action_vars": [], + "range": { + "start": 202955, + "end": 203018 + } + }, + { + "id": "effect_1", + "effect_id": "effect@203028:203052", + "bound_var": null, + "source_text": "ctx.union(pat.above, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "above" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 203028, + "end": 203052 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0049", + "premises": [ + { + "target_id": "_rel1", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "plain_source": "upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"pred_from\"), upright(\"pred_to\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred_from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred_to\") $]) $]" + }, + { + "target_id": "_rel2", + "label": "_rel2: Ecxcan_subst_VecOperand_beneath", + "plain_source": "upright(\"can_subst_VecOperand_beneath\")(upright(\"above\"), upright(\"outputs_from\"), upright(\"outputs_to\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_VecOperand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs_from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs_to\") $]) $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxTheta", + "plain_source": "upright(\"Theta\")(upright(\"pred_from\"), upright(\"inputs\"), upright(\"outputs_from\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred_from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs_from\") $]) $]" + } + ], + "side_conditions": [ + "upright(\"above\") == upright(\"_t3\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"Theta\")(upright(\"pred_from\"), upright(\"inputs\"), upright(\"outputs_to\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred_from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs_to\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "above", + "label": "above: EcxBody", + "plain_source": "upright(\"above\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"Theta\")(upright(\"pred_from\"), upright(\"inputs\"), upright(\"outputs_to\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred_from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs_to\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"pred_from\"), upright(\"pred_to\")) \\ upright(\"can_subst_VecOperand_beneath\")(upright(\"above\"), upright(\"outputs_from\"), upright(\"outputs_to\")) \\ upright(\"Theta\")(upright(\"pred_from\"), upright(\"inputs\"), upright(\"outputs_from\")), upright(\"above\") arrow.r.double upright(\"Theta\")(upright(\"pred_from\"), upright(\"inputs\"), upright(\"outputs_to\"))) quad upright(\"if\") quad upright(\"above\") == upright(\"_t3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred_from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred_to\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_VecOperand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs_from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs_to\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred_from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs_from\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred_from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs_to\") $]) $]) quad upright(\"if\") quad upright(\"above\") == upright(\"_t3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6787_5_MyTxEggccExtraction_add_rule__r0050__05a238435e1086aa", + "display_name": "r0050", + "rule_name": "r0050", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 203066, + "line": 6787, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 203066, + "end": 203247 + }, + "pattern_range": { + "start": 203112, + "end": 203123 + }, + "action_range": { + "start": 203125, + "end": 203246 + } + }, + "nodes": [ + { + "id": "above", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "above: EcxBody", + "range": { + "start": 52435, + "end": 52469 + }, + "inputs": [] + }, + { + "id": "from", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "from: EcxVecVecOperand", + "range": { + "start": 52474, + "end": 52516 + }, + "inputs": [] + }, + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 52521, + "end": 52562 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 52567, + "end": 52603 + }, + "inputs": [] + }, + { + "id": "to", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "to: EcxVecVecOperand", + "range": { + "start": 52608, + "end": 52648 + }, + "inputs": [] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "Ecxcan_subst_VecVecOperand_beneath", + "label": "_rel1: Ecxcan_subst_VecVecOperand_beneath", + "range": { + "start": 52653, + "end": 52727 + }, + "inputs": [ + "above", + "from", + "to" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxGamma", + "label": "_t2: EcxGamma", + "range": { + "start": 52732, + "end": 52781 + }, + "inputs": [ + "pred", + "inputs", + "from" + ] + } + ], + "edges": [ + { + "from": "_rel1", + "to": "above", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel1", + "to": "to", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "from", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "above", + "from", + "inputs", + "pred", + "to", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "above.handle().eq(&_t2.handle())", + "semantic_text": "above == _t2", + "referenced_vars": [ + "_t2", + "above" + ], + "range": { + "start": 52896, + "end": 52898 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@203155:203205", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_gamma(pat.pred, pat.inputs, pat.to)", + "semantic_text": null, + "referenced_pat_vars": [ + "inputs", + "pred", + "to" + ], + "referenced_action_vars": [], + "range": { + "start": 203155, + "end": 203205 + } + }, + { + "id": "effect_1", + "effect_id": "effect@203215:203239", + "bound_var": null, + "source_text": "ctx.union(pat.above, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "above" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 203215, + "end": 203239 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0050", + "premises": [ + { + "target_id": "_rel1", + "label": "_rel1: Ecxcan_subst_VecVecOperand_beneath", + "plain_source": "upright(\"can_subst_VecVecOperand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_VecVecOperand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxGamma", + "plain_source": "upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"from\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $]) $]" + } + ], + "side_conditions": [ + "upright(\"above\") == upright(\"_t2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "above", + "label": "above: EcxBody", + "plain_source": "upright(\"above\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"can_subst_VecVecOperand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\")) \\ upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"from\")), upright(\"above\") arrow.r.double upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"to\"))) quad upright(\"if\") quad upright(\"above\") == upright(\"_t2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_VecVecOperand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]) quad upright(\"if\") quad upright(\"above\") == upright(\"_t2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6791_5_MyTxEggccExtraction_add_rule__r0051__9fd56dcb97b49212", + "display_name": "r0051", + "rule_name": "r0051", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 203253, + "line": 6791, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 203253, + "end": 203420 + }, + "pattern_range": { + "start": 203299, + "end": 203310 + }, + "action_range": { + "start": 203312, + "end": 203419 + } + }, + "nodes": [ + { + "id": "above", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "above: EcxBody", + "range": { + "start": 53151, + "end": 53185 + }, + "inputs": [] + }, + { + "id": "from", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "from: EcxVecOperand", + "range": { + "start": 53190, + "end": 53229 + }, + "inputs": [] + }, + { + "id": "to", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "to: EcxVecOperand", + "range": { + "start": 53234, + "end": 53271 + }, + "inputs": [] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "Ecxcan_subst_VecOperand_beneath", + "label": "_rel1: Ecxcan_subst_VecOperand_beneath", + "range": { + "start": 53276, + "end": 53347 + }, + "inputs": [ + "above", + "from", + "to" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxOperandGroup", + "label": "_t2: EcxOperandGroup", + "range": { + "start": 53352, + "end": 53392 + }, + "inputs": [ + "from" + ] + } + ], + "edges": [ + { + "from": "_rel1", + "to": "above", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel1", + "to": "to", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "from", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "above", + "from", + "to", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "above.handle().eq(&_t2.handle())", + "semantic_text": "above == _t2", + "referenced_vars": [ + "_t2", + "above" + ], + "range": { + "start": 53493, + "end": 53495 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@203342:203378", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_operand_group(pat.to)", + "semantic_text": null, + "referenced_pat_vars": [ + "to" + ], + "referenced_action_vars": [], + "range": { + "start": 203342, + "end": 203378 + } + }, + { + "id": "effect_1", + "effect_id": "effect@203388:203412", + "bound_var": null, + "source_text": "ctx.union(pat.above, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "above" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 203388, + "end": 203412 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0051", + "premises": [ + { + "target_id": "_rel1", + "label": "_rel1: Ecxcan_subst_VecOperand_beneath", + "plain_source": "upright(\"can_subst_VecOperand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_VecOperand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxOperandGroup", + "plain_source": "upright(\"OperandGroup\")(upright(\"from\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"OperandGroup\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $]) $]" + } + ], + "side_conditions": [ + "upright(\"above\") == upright(\"_t2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"OperandGroup\")(upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "above", + "label": "above: EcxBody", + "plain_source": "upright(\"above\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"OperandGroup\")(upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"can_subst_VecOperand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\")) \\ upright(\"OperandGroup\")(upright(\"from\")), upright(\"above\") arrow.r.double upright(\"OperandGroup\")(upright(\"to\"))) quad upright(\"if\") quad upright(\"above\") == upright(\"_t2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_VecOperand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"OperandGroup\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]) quad upright(\"if\") quad upright(\"above\") == upright(\"_t2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6795_5_MyTxEggccExtraction_add_rule__r0052__bb59819638960af3", + "display_name": "r0052", + "rule_name": "r0052", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 203426, + "line": 6795, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 203426, + "end": 203639 + }, + "pattern_range": { + "start": 203472, + "end": 203483 + }, + "action_range": { + "start": 203485, + "end": 203638 + } + }, + "nodes": [ + { + "id": "above", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "above: EcxBody", + "range": { + "start": 53748, + "end": 53782 + }, + "inputs": [] + }, + { + "id": "from", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "from: EcxBody", + "range": { + "start": 53787, + "end": 53820 + }, + "inputs": [] + }, + { + "id": "new_from", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "new_from: EcxOperand", + "range": { + "start": 53825, + "end": 53865 + }, + "inputs": [] + }, + { + "id": "to", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "to: EcxBody", + "range": { + "start": 53870, + "end": 53901 + }, + "inputs": [] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "Ecxcan_subst_Body_beneath", + "label": "_rel1: Ecxcan_subst_Body_beneath", + "range": { + "start": 53906, + "end": 53971 + }, + "inputs": [ + "above", + "from", + "to" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t2: EcxNode", + "range": { + "start": 53976, + "end": 54008 + }, + "inputs": [ + "from" + ] + } + ], + "edges": [ + { + "from": "_rel1", + "to": "above", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel1", + "to": "to", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "from", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "above", + "from", + "new_from", + "to", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "new_from.handle().eq(&_t2.handle())", + "semantic_text": "new_from == _t2", + "referenced_vars": [ + "_t2", + "new_from" + ], + "range": { + "start": 54122, + "end": 54124 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@203515:203542", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_node(pat.to)", + "semantic_text": null, + "referenced_pat_vars": [ + "to" + ], + "referenced_action_vars": [], + "range": { + "start": 203515, + "end": 203542 + } + }, + { + "id": "effect_1", + "effect_id": "effect@203563:203631", + "bound_var": "rel1", + "source_text": "ctx.insert_ecxcan_subst_operand_beneath(pat.above, pat.new_from, t2)", + "semantic_text": null, + "referenced_pat_vars": [ + "above", + "new_from" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 203563, + "end": 203631 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0052", + "premises": [ + { + "target_id": "_rel1", + "label": "_rel1: Ecxcan_subst_Body_beneath", + "plain_source": "upright(\"can_subst_Body_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Body_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxNode", + "plain_source": "upright(\"Node\")(upright(\"from\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $]) $]" + } + ], + "side_conditions": [ + "upright(\"new_from\") == upright(\"_t2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"Node\")(upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Node\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstOperandBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"Node\")(upright(\"to\")))", + "colored_source": "upright(\"EcxcanSubstOperandBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Node\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstOperandBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"Node\")(upright(\"to\")))", + "colored_source": "upright(\"EcxcanSubstOperandBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Node\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"can_subst_Body_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\")) \\ upright(\"Node\")(upright(\"from\")), upright(\"EcxcanSubstOperandBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"Node\")(upright(\"to\")))) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Body_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $]) $], upright(\"EcxcanSubstOperandBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Node\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $])) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6799_5_MyTxEggccExtraction_add_rule__r0053__cb4404db3e04b144", + "display_name": "r0053", + "rule_name": "r0053", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 203645, + "line": 6799, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 203645, + "end": 203881 + }, + "pattern_range": { + "start": 203691, + "end": 203702 + }, + "action_range": { + "start": 203704, + "end": 203880 + } + }, + "nodes": [ + { + "id": "above", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "above: EcxBody", + "range": { + "start": 54392, + "end": 54426 + }, + "inputs": [] + }, + { + "id": "from", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "from: EcxBody", + "range": { + "start": 54431, + "end": 54464 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 54469, + "end": 54514 + }, + "inputs": [] + }, + { + "id": "new_from", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "new_from: EcxOperand", + "range": { + "start": 54519, + "end": 54559 + }, + "inputs": [] + }, + { + "id": "to", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "to: EcxBody", + "range": { + "start": 54564, + "end": 54595 + }, + "inputs": [] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "Ecxcan_subst_Body_beneath", + "label": "_rel1: Ecxcan_subst_Body_beneath", + "range": { + "start": 54600, + "end": 54665 + }, + "inputs": [ + "above", + "from", + "to" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxProject", + "label": "_t2: EcxProject", + "range": { + "start": 54670, + "end": 54705 + }, + "inputs": [ + "from" + ] + } + ], + "edges": [ + { + "from": "_rel1", + "to": "above", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel1", + "to": "to", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "from", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "above", + "from", + "i", + "new_from", + "to", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_t2.handle_a0())", + "semantic_text": "i == _t2.a0", + "referenced_vars": [ + "_t2", + "i" + ], + "range": { + "start": 54877, + "end": 54879 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "new_from.handle().eq(&_t2.handle())", + "semantic_text": "new_from == _t2", + "referenced_vars": [ + "_t2", + "new_from" + ], + "range": { + "start": 54897, + "end": 54899 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@203734:203784", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_project(ctx.devalue(pat.i), pat.to)", + "semantic_text": null, + "referenced_pat_vars": [ + "i", + "to" + ], + "referenced_action_vars": [], + "range": { + "start": 203734, + "end": 203784 + } + }, + { + "id": "effect_1", + "effect_id": "effect@203805:203873", + "bound_var": "rel1", + "source_text": "ctx.insert_ecxcan_subst_operand_beneath(pat.above, pat.new_from, t2)", + "semantic_text": null, + "referenced_pat_vars": [ + "above", + "new_from" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 203805, + "end": 203873 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0053", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_rel1", + "label": "_rel1: Ecxcan_subst_Body_beneath", + "plain_source": "upright(\"can_subst_Body_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Body_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxProject", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + } + ], + "side_conditions": [ + "i == upright(\"_t2.a0\")", + "upright(\"new_from\") == upright(\"_t2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"Project\")(i, upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Project\")(#text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstOperandBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"Project\")(i, upright(\"to\")))", + "colored_source": "upright(\"EcxcanSubstOperandBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Project\")(#text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstOperandBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"Project\")(i, upright(\"to\")))", + "colored_source": "upright(\"EcxcanSubstOperandBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Project\")(#text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $])" + } + } + ], + "formula_source": { + "plain": "frac(i \\ upright(\"can_subst_Body_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\")) \\ upright(\"_t2\"), upright(\"EcxcanSubstOperandBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"Project\")(i, upright(\"to\")))) quad upright(\"if\") quad i == upright(\"_t2.a0\") \\ upright(\"new_from\") == upright(\"_t2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Body_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], upright(\"EcxcanSubstOperandBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Project\")(#text(fill: rgb(\"#5F7A8A\"))[$ i $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $])) quad upright(\"if\") quad i == upright(\"_t2.a0\") \\ upright(\"new_from\") == upright(\"_t2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6803_5_MyTxEggccExtraction_add_rule__r0054__ed8c64084015bb37", + "display_name": "r0054", + "rule_name": "r0054", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 203887, + "line": 6803, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 203887, + "end": 204100 + }, + "pattern_range": { + "start": 203933, + "end": 203944 + }, + "action_range": { + "start": 203946, + "end": 204099 + } + }, + "nodes": [ + { + "id": "above", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "above: EcxBody", + "range": { + "start": 55151, + "end": 55185 + }, + "inputs": [] + }, + { + "id": "from", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "from: EcxExpr", + "range": { + "start": 55190, + "end": 55223 + }, + "inputs": [] + }, + { + "id": "new_from", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "new_from: EcxBody", + "range": { + "start": 55228, + "end": 55265 + }, + "inputs": [] + }, + { + "id": "to", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "to: EcxExpr", + "range": { + "start": 55270, + "end": 55301 + }, + "inputs": [] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "Ecxcan_subst_Expr_beneath", + "label": "_rel1: Ecxcan_subst_Expr_beneath", + "range": { + "start": 55306, + "end": 55371 + }, + "inputs": [ + "above", + "from", + "to" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t2: EcxPureOp", + "range": { + "start": 55376, + "end": 55410 + }, + "inputs": [ + "from" + ] + } + ], + "edges": [ + { + "from": "_rel1", + "to": "above", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel1", + "to": "to", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "from", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "above", + "from", + "new_from", + "to", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "new_from.handle().eq(&_t2.handle())", + "semantic_text": "new_from == _t2", + "referenced_vars": [ + "_t2", + "new_from" + ], + "range": { + "start": 55524, + "end": 55526 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@203976:204006", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_pure_op(pat.to)", + "semantic_text": null, + "referenced_pat_vars": [ + "to" + ], + "referenced_action_vars": [], + "range": { + "start": 203976, + "end": 204006 + } + }, + { + "id": "effect_1", + "effect_id": "effect@204027:204092", + "bound_var": "rel1", + "source_text": "ctx.insert_ecxcan_subst_body_beneath(pat.above, pat.new_from, t2)", + "semantic_text": null, + "referenced_pat_vars": [ + "above", + "new_from" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 204027, + "end": 204092 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0054", + "premises": [ + { + "target_id": "_rel1", + "label": "_rel1: Ecxcan_subst_Expr_beneath", + "plain_source": "upright(\"can_subst_Expr_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Expr_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxPureOp", + "plain_source": "upright(\"PureOp\")(upright(\"from\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $]) $]" + } + ], + "side_conditions": [ + "upright(\"new_from\") == upright(\"_t2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"PureOp\")(upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstBodyBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"PureOp\")(upright(\"to\")))", + "colored_source": "upright(\"EcxcanSubstBodyBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstBodyBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"PureOp\")(upright(\"to\")))", + "colored_source": "upright(\"EcxcanSubstBodyBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"can_subst_Expr_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\")) \\ upright(\"PureOp\")(upright(\"from\")), upright(\"EcxcanSubstBodyBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"PureOp\")(upright(\"to\")))) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Expr_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $]) $], upright(\"EcxcanSubstBodyBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $])) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6807_5_MyTxEggccExtraction_add_rule__r0055__4f519567e90fca68", + "display_name": "r0055", + "rule_name": "r0055", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 204106, + "line": 6807, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 204106, + "end": 204342 + }, + "pattern_range": { + "start": 204152, + "end": 204163 + }, + "action_range": { + "start": 204165, + "end": 204341 + } + }, + "nodes": [ + { + "id": "above", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "above: EcxBody", + "range": { + "start": 55844, + "end": 55878 + }, + "inputs": [] + }, + { + "id": "from", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "from: EcxOperand", + "range": { + "start": 55883, + "end": 55919 + }, + "inputs": [] + }, + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 55924, + "end": 55965 + }, + "inputs": [] + }, + { + "id": "new_from", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "new_from: EcxBody", + "range": { + "start": 55970, + "end": 56007 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "outputs: EcxVecVecOperand", + "range": { + "start": 56012, + "end": 56057 + }, + "inputs": [] + }, + { + "id": "to", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "to: EcxOperand", + "range": { + "start": 56062, + "end": 56096 + }, + "inputs": [] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "Ecxcan_subst_Operand_beneath", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "range": { + "start": 56101, + "end": 56169 + }, + "inputs": [ + "above", + "from", + "to" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxGamma", + "label": "_t2: EcxGamma", + "range": { + "start": 56174, + "end": 56226 + }, + "inputs": [ + "from", + "inputs", + "outputs" + ] + } + ], + "edges": [ + { + "from": "_rel1", + "to": "above", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel1", + "to": "to", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "from", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "outputs", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "above", + "from", + "inputs", + "new_from", + "outputs", + "to", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "new_from.handle().eq(&_t2.handle())", + "semantic_text": "new_from == _t2", + "referenced_vars": [ + "_t2", + "new_from" + ], + "range": { + "start": 56357, + "end": 56359 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@204195:204248", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_gamma(pat.to, pat.inputs, pat.outputs)", + "semantic_text": null, + "referenced_pat_vars": [ + "inputs", + "outputs", + "to" + ], + "referenced_action_vars": [], + "range": { + "start": 204195, + "end": 204248 + } + }, + { + "id": "effect_1", + "effect_id": "effect@204269:204334", + "bound_var": "rel1", + "source_text": "ctx.insert_ecxcan_subst_body_beneath(pat.above, pat.new_from, t2)", + "semantic_text": null, + "referenced_pat_vars": [ + "above", + "new_from" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 204269, + "end": 204334 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0055", + "premises": [ + { + "target_id": "_rel1", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "plain_source": "upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxGamma", + "plain_source": "upright(\"Gamma\")(upright(\"from\"), upright(\"inputs\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + ], + "side_conditions": [ + "upright(\"new_from\") == upright(\"_t2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"Gamma\")(upright(\"to\"), upright(\"inputs\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstBodyBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"Gamma\")(upright(\"to\"), upright(\"inputs\"), upright(\"outputs\")))", + "colored_source": "upright(\"EcxcanSubstBodyBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstBodyBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"Gamma\")(upright(\"to\"), upright(\"inputs\"), upright(\"outputs\")))", + "colored_source": "upright(\"EcxcanSubstBodyBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\")) \\ upright(\"Gamma\")(upright(\"from\"), upright(\"inputs\"), upright(\"outputs\")), upright(\"EcxcanSubstBodyBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"Gamma\")(upright(\"to\"), upright(\"inputs\"), upright(\"outputs\")))) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $], upright(\"EcxcanSubstBodyBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6811_5_MyTxEggccExtraction_add_rule__r0056__3f43280216fcf876", + "display_name": "r0056", + "rule_name": "r0056", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 204348, + "line": 6811, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 204348, + "end": 204582 + }, + "pattern_range": { + "start": 204394, + "end": 204405 + }, + "action_range": { + "start": 204407, + "end": 204581 + } + }, + "nodes": [ + { + "id": "above", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "above: EcxBody", + "range": { + "start": 56681, + "end": 56715 + }, + "inputs": [] + }, + { + "id": "from", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "from: EcxVecOperand", + "range": { + "start": 56720, + "end": 56759 + }, + "inputs": [] + }, + { + "id": "new_from", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "new_from: EcxBody", + "range": { + "start": 56764, + "end": 56801 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "outputs: EcxVecVecOperand", + "range": { + "start": 56806, + "end": 56851 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 56856, + "end": 56892 + }, + "inputs": [] + }, + { + "id": "to", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "to: EcxVecOperand", + "range": { + "start": 56897, + "end": 56934 + }, + "inputs": [] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "Ecxcan_subst_VecOperand_beneath", + "label": "_rel1: Ecxcan_subst_VecOperand_beneath", + "range": { + "start": 56939, + "end": 57010 + }, + "inputs": [ + "above", + "from", + "to" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxGamma", + "label": "_t2: EcxGamma", + "range": { + "start": 57015, + "end": 57065 + }, + "inputs": [ + "pred", + "from", + "outputs" + ] + } + ], + "edges": [ + { + "from": "_rel1", + "to": "above", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel1", + "to": "to", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "outputs", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "above", + "from", + "new_from", + "outputs", + "pred", + "to", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "new_from.handle().eq(&_t2.handle())", + "semantic_text": "new_from == _t2", + "referenced_vars": [ + "_t2", + "new_from" + ], + "range": { + "start": 57194, + "end": 57196 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@204437:204488", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_gamma(pat.pred, pat.to, pat.outputs)", + "semantic_text": null, + "referenced_pat_vars": [ + "outputs", + "pred", + "to" + ], + "referenced_action_vars": [], + "range": { + "start": 204437, + "end": 204488 + } + }, + { + "id": "effect_1", + "effect_id": "effect@204509:204574", + "bound_var": "rel1", + "source_text": "ctx.insert_ecxcan_subst_body_beneath(pat.above, pat.new_from, t2)", + "semantic_text": null, + "referenced_pat_vars": [ + "above", + "new_from" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 204509, + "end": 204574 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0056", + "premises": [ + { + "target_id": "_rel1", + "label": "_rel1: Ecxcan_subst_VecOperand_beneath", + "plain_source": "upright(\"can_subst_VecOperand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_VecOperand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxGamma", + "plain_source": "upright(\"Gamma\")(upright(\"pred\"), upright(\"from\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + ], + "side_conditions": [ + "upright(\"new_from\") == upright(\"_t2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"Gamma\")(upright(\"pred\"), upright(\"to\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstBodyBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"Gamma\")(upright(\"pred\"), upright(\"to\"), upright(\"outputs\")))", + "colored_source": "upright(\"EcxcanSubstBodyBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstBodyBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"Gamma\")(upright(\"pred\"), upright(\"to\"), upright(\"outputs\")))", + "colored_source": "upright(\"EcxcanSubstBodyBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"can_subst_VecOperand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\")) \\ upright(\"Gamma\")(upright(\"pred\"), upright(\"from\"), upright(\"outputs\")), upright(\"EcxcanSubstBodyBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"Gamma\")(upright(\"pred\"), upright(\"to\"), upright(\"outputs\")))) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_VecOperand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $], upright(\"EcxcanSubstBodyBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6815_5_MyTxEggccExtraction_add_rule__r0057__3ec89f22e76bc74d", + "display_name": "r0057", + "rule_name": "r0057", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 204588, + "line": 6815, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 204588, + "end": 204822 + }, + "pattern_range": { + "start": 204634, + "end": 204645 + }, + "action_range": { + "start": 204647, + "end": 204821 + } + }, + "nodes": [ + { + "id": "above", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "above: EcxBody", + "range": { + "start": 57515, + "end": 57549 + }, + "inputs": [] + }, + { + "id": "from", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "from: EcxVecOperand", + "range": { + "start": 57554, + "end": 57593 + }, + "inputs": [] + }, + { + "id": "new_from", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "new_from: EcxBody", + "range": { + "start": 57598, + "end": 57635 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "outputs: EcxVecOperand", + "range": { + "start": 57640, + "end": 57682 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 57687, + "end": 57723 + }, + "inputs": [] + }, + { + "id": "to", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "to: EcxVecOperand", + "range": { + "start": 57728, + "end": 57765 + }, + "inputs": [] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "Ecxcan_subst_VecOperand_beneath", + "label": "_rel1: Ecxcan_subst_VecOperand_beneath", + "range": { + "start": 57770, + "end": 57841 + }, + "inputs": [ + "above", + "from", + "to" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxTheta", + "label": "_t2: EcxTheta", + "range": { + "start": 57846, + "end": 57896 + }, + "inputs": [ + "pred", + "from", + "outputs" + ] + } + ], + "edges": [ + { + "from": "_rel1", + "to": "above", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel1", + "to": "to", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "outputs", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "above", + "from", + "new_from", + "outputs", + "pred", + "to", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "new_from.handle().eq(&_t2.handle())", + "semantic_text": "new_from == _t2", + "referenced_vars": [ + "_t2", + "new_from" + ], + "range": { + "start": 58025, + "end": 58027 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@204677:204728", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_theta(pat.pred, pat.to, pat.outputs)", + "semantic_text": null, + "referenced_pat_vars": [ + "outputs", + "pred", + "to" + ], + "referenced_action_vars": [], + "range": { + "start": 204677, + "end": 204728 + } + }, + { + "id": "effect_1", + "effect_id": "effect@204749:204814", + "bound_var": "rel1", + "source_text": "ctx.insert_ecxcan_subst_body_beneath(pat.above, pat.new_from, t2)", + "semantic_text": null, + "referenced_pat_vars": [ + "above", + "new_from" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 204749, + "end": 204814 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0057", + "premises": [ + { + "target_id": "_rel1", + "label": "_rel1: Ecxcan_subst_VecOperand_beneath", + "plain_source": "upright(\"can_subst_VecOperand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_VecOperand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxTheta", + "plain_source": "upright(\"Theta\")(upright(\"pred\"), upright(\"from\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + ], + "side_conditions": [ + "upright(\"new_from\") == upright(\"_t2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"Theta\")(upright(\"pred\"), upright(\"to\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstBodyBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"Theta\")(upright(\"pred\"), upright(\"to\"), upright(\"outputs\")))", + "colored_source": "upright(\"EcxcanSubstBodyBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstBodyBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"Theta\")(upright(\"pred\"), upright(\"to\"), upright(\"outputs\")))", + "colored_source": "upright(\"EcxcanSubstBodyBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"can_subst_VecOperand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\")) \\ upright(\"Theta\")(upright(\"pred\"), upright(\"from\"), upright(\"outputs\")), upright(\"EcxcanSubstBodyBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"Theta\")(upright(\"pred\"), upright(\"to\"), upright(\"outputs\")))) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_VecOperand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $], upright(\"EcxcanSubstBodyBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6819_5_MyTxEggccExtraction_add_rule__r0058__7469ee9fcba4e32c", + "display_name": "r0058", + "rule_name": "r0058", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 204828, + "line": 6819, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 204828, + "end": 205047 + }, + "pattern_range": { + "start": 204874, + "end": 204885 + }, + "action_range": { + "start": 204887, + "end": 205046 + } + }, + "nodes": [ + { + "id": "above", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "above: EcxBody", + "range": { + "start": 58303, + "end": 58337 + }, + "inputs": [] + }, + { + "id": "from", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "from: EcxVecOperand", + "range": { + "start": 58342, + "end": 58381 + }, + "inputs": [] + }, + { + "id": "new_from", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "new_from: EcxBody", + "range": { + "start": 58386, + "end": 58423 + }, + "inputs": [] + }, + { + "id": "to", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "to: EcxVecOperand", + "range": { + "start": 58428, + "end": 58465 + }, + "inputs": [] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "Ecxcan_subst_VecOperand_beneath", + "label": "_rel1: Ecxcan_subst_VecOperand_beneath", + "range": { + "start": 58470, + "end": 58541 + }, + "inputs": [ + "above", + "from", + "to" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxOperandGroup", + "label": "_t2: EcxOperandGroup", + "range": { + "start": 58546, + "end": 58586 + }, + "inputs": [ + "from" + ] + } + ], + "edges": [ + { + "from": "_rel1", + "to": "above", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel1", + "to": "to", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "from", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "above", + "from", + "new_from", + "to", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "new_from.handle().eq(&_t2.handle())", + "semantic_text": "new_from == _t2", + "referenced_vars": [ + "_t2", + "new_from" + ], + "range": { + "start": 58700, + "end": 58702 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@204917:204953", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_operand_group(pat.to)", + "semantic_text": null, + "referenced_pat_vars": [ + "to" + ], + "referenced_action_vars": [], + "range": { + "start": 204917, + "end": 204953 + } + }, + { + "id": "effect_1", + "effect_id": "effect@204974:205039", + "bound_var": "rel1", + "source_text": "ctx.insert_ecxcan_subst_body_beneath(pat.above, pat.new_from, t2)", + "semantic_text": null, + "referenced_pat_vars": [ + "above", + "new_from" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 204974, + "end": 205039 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0058", + "premises": [ + { + "target_id": "_rel1", + "label": "_rel1: Ecxcan_subst_VecOperand_beneath", + "plain_source": "upright(\"can_subst_VecOperand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_VecOperand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxOperandGroup", + "plain_source": "upright(\"OperandGroup\")(upright(\"from\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"OperandGroup\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $]) $]" + } + ], + "side_conditions": [ + "upright(\"new_from\") == upright(\"_t2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"OperandGroup\")(upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstBodyBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"OperandGroup\")(upright(\"to\")))", + "colored_source": "upright(\"EcxcanSubstBodyBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstBodyBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"OperandGroup\")(upright(\"to\")))", + "colored_source": "upright(\"EcxcanSubstBodyBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"can_subst_VecOperand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\")) \\ upright(\"OperandGroup\")(upright(\"from\")), upright(\"EcxcanSubstBodyBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"OperandGroup\")(upright(\"to\")))) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_VecOperand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"OperandGroup\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $]) $], upright(\"EcxcanSubstBodyBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $])) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6823_5_MyTxEggccExtraction_add_rule__r0059__cb0587b6d90c44ea", + "display_name": "r0059", + "rule_name": "r0059", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 205053, + "line": 6823, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 205053, + "end": 205316 + }, + "pattern_range": { + "start": 205099, + "end": 205110 + }, + "action_range": { + "start": 205112, + "end": 205315 + } + }, + "nodes": [ + { + "id": "above", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "above: EcxBody", + "range": { + "start": 59025, + "end": 59059 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query", + "dsl_type": "", + "label": "f: ", + "range": { + "start": 59064, + "end": 59112 + }, + "inputs": [] + }, + { + "id": "from", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "from: EcxVecOperand", + "range": { + "start": 59117, + "end": 59156 + }, + "inputs": [] + }, + { + "id": "n_outs", + "kind": "query", + "dsl_type": "", + "label": "n_outs: ", + "range": { + "start": 59161, + "end": 59216 + }, + "inputs": [] + }, + { + "id": "new_from", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "new_from: EcxExpr", + "range": { + "start": 59221, + "end": 59258 + }, + "inputs": [] + }, + { + "id": "to", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "to: EcxVecOperand", + "range": { + "start": 59263, + "end": 59300 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxOptionType", + "label": "ty: EcxOptionType", + "range": { + "start": 59305, + "end": 59342 + }, + "inputs": [] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "Ecxcan_subst_VecOperand_beneath", + "label": "_rel1: Ecxcan_subst_VecOperand_beneath", + "range": { + "start": 59347, + "end": 59418 + }, + "inputs": [ + "above", + "from", + "to" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxCall", + "label": "_t2: EcxCall", + "range": { + "start": 59423, + "end": 59460 + }, + "inputs": [ + "ty", + "from" + ] + } + ], + "edges": [ + { + "from": "_rel1", + "to": "above", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel1", + "to": "to", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "from", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "above", + "f", + "from", + "n_outs", + "new_from", + "to", + "ty", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "f.handle().eq(&_t2.handle_a1())", + "semantic_text": "f == _t2.a1", + "referenced_vars": [ + "_t2", + "f" + ], + "range": { + "start": 59695, + "end": 59697 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "n_outs.handle().eq(&_t2.handle_a3())", + "semantic_text": "n_outs == _t2.a3", + "referenced_vars": [ + "_t2", + "n_outs" + ], + "range": { + "start": 59715, + "end": 59717 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "new_from.handle().eq(&_t2.handle())", + "semantic_text": "new_from == _t2", + "referenced_vars": [ + "_t2", + "new_from" + ], + "range": { + "start": 59735, + "end": 59737 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@205142:205222", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_call(pat.ty, ctx.devalue(pat.f), pat.to, ctx.devalue(pat.n_outs))", + "semantic_text": null, + "referenced_pat_vars": [ + "f", + "n_outs", + "to", + "ty" + ], + "referenced_action_vars": [], + "range": { + "start": 205142, + "end": 205222 + } + }, + { + "id": "effect_1", + "effect_id": "effect@205243:205308", + "bound_var": "rel1", + "source_text": "ctx.insert_ecxcan_subst_expr_beneath(pat.above, pat.new_from, t2)", + "semantic_text": null, + "referenced_pat_vars": [ + "above", + "new_from" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 205243, + "end": 205308 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0059", + "premises": [ + { + "target_id": "f", + "label": "f: ", + "plain_source": "f", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ f $]" + }, + { + "target_id": "n_outs", + "label": "n_outs: ", + "plain_source": "upright(\"n_outs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"n_outs\") $]" + }, + { + "target_id": "_rel1", + "label": "_rel1: Ecxcan_subst_VecOperand_beneath", + "plain_source": "upright(\"can_subst_VecOperand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_VecOperand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxCall", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + } + ], + "side_conditions": [ + "f == upright(\"_t2.a1\")", + "upright(\"n_outs\") == upright(\"_t2.a3\")", + "upright(\"new_from\") == upright(\"_t2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"Call\")(upright(\"ty\"), f, upright(\"to\"), upright(\"n_outs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Call\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"n_outs\") $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"Call\")(upright(\"ty\"), f, upright(\"to\"), upright(\"n_outs\")))", + "colored_source": "upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Call\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"n_outs\") $]) $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"Call\")(upright(\"ty\"), f, upright(\"to\"), upright(\"n_outs\")))", + "colored_source": "upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Call\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"n_outs\") $]) $])" + } + } + ], + "formula_source": { + "plain": "frac(f \\ upright(\"n_outs\") \\ upright(\"can_subst_VecOperand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\")) \\ upright(\"_t2\"), upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"Call\")(upright(\"ty\"), f, upright(\"to\"), upright(\"n_outs\")))) quad upright(\"if\") quad f == upright(\"_t2.a1\") \\ upright(\"n_outs\") == upright(\"_t2.a3\") \\ upright(\"new_from\") == upright(\"_t2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ f $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"n_outs\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_VecOperand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Call\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ f $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"n_outs\") $]) $])) quad upright(\"if\") quad f == upright(\"_t2.a1\") \\ upright(\"n_outs\") == upright(\"_t2.a3\") \\ upright(\"new_from\") == upright(\"_t2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6827_5_MyTxEggccExtraction_add_rule__r0060__3600363b1d442f22", + "display_name": "r0060", + "rule_name": "r0060", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 205322, + "line": 6827, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 205322, + "end": 205552 + }, + "pattern_range": { + "start": 205368, + "end": 205379 + }, + "action_range": { + "start": 205381, + "end": 205551 + } + }, + "nodes": [ + { + "id": "above", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "above: EcxBody", + "range": { + "start": 60038, + "end": 60072 + }, + "inputs": [] + }, + { + "id": "e2", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e2: EcxOperand", + "range": { + "start": 60077, + "end": 60111 + }, + "inputs": [] + }, + { + "id": "from", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "from: EcxOperand", + "range": { + "start": 60116, + "end": 60152 + }, + "inputs": [] + }, + { + "id": "new_from", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "new_from: EcxExpr", + "range": { + "start": 60157, + "end": 60194 + }, + "inputs": [] + }, + { + "id": "to", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "to: EcxOperand", + "range": { + "start": 60199, + "end": 60233 + }, + "inputs": [] + }, + { + "id": "kw_type", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "kw_type: EcxType", + "range": { + "start": 60238, + "end": 60274 + }, + "inputs": [] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "Ecxcan_subst_Operand_beneath", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "range": { + "start": 60279, + "end": 60347 + }, + "inputs": [ + "above", + "from", + "to" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxbadd", + "label": "_t2: Ecxbadd", + "range": { + "start": 60352, + "end": 60399 + }, + "inputs": [ + "kw_type", + "from", + "e2" + ] + } + ], + "edges": [ + { + "from": "_rel1", + "to": "above", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel1", + "to": "to", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "kw_type", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "e2", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "above", + "e2", + "from", + "new_from", + "to", + "kw_type", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "new_from.handle().eq(&_t2.handle())", + "semantic_text": "new_from == _t2", + "referenced_vars": [ + "_t2", + "new_from" + ], + "range": { + "start": 60526, + "end": 60528 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@205411:205458", + "bound_var": "t2", + "source_text": "ctx.insert_ecxbadd(pat.kw_type, pat.to, pat.e2)", + "semantic_text": null, + "referenced_pat_vars": [ + "e2", + "kw_type", + "to" + ], + "referenced_action_vars": [], + "range": { + "start": 205411, + "end": 205458 + } + }, + { + "id": "effect_1", + "effect_id": "effect@205479:205544", + "bound_var": "rel1", + "source_text": "ctx.insert_ecxcan_subst_expr_beneath(pat.above, pat.new_from, t2)", + "semantic_text": null, + "referenced_pat_vars": [ + "above", + "new_from" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 205479, + "end": 205544 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0060", + "premises": [ + { + "target_id": "_rel1", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "plain_source": "upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxbadd", + "plain_source": "upright(\"badd\")(upright(\"kw_type\"), upright(\"from\"), e_2)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $]" + } + ], + "side_conditions": [ + "upright(\"new_from\") == upright(\"_t2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"badd\")(upright(\"kw_type\"), upright(\"to\"), e_2)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"badd\")(upright(\"kw_type\"), upright(\"to\"), e_2))", + "colored_source": "upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"badd\")(upright(\"kw_type\"), upright(\"to\"), e_2))", + "colored_source": "upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\")) \\ upright(\"badd\")(upright(\"kw_type\"), upright(\"from\"), e_2), upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"badd\")(upright(\"kw_type\"), upright(\"to\"), e_2))) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $], upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $])) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6831_5_MyTxEggccExtraction_add_rule__r0061__1fed6bd45c7405ae", + "display_name": "r0061", + "rule_name": "r0061", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 205558, + "line": 6831, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 205558, + "end": 205788 + }, + "pattern_range": { + "start": 205604, + "end": 205615 + }, + "action_range": { + "start": 205617, + "end": 205787 + } + }, + "nodes": [ + { + "id": "above", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "above: EcxBody", + "range": { + "start": 60829, + "end": 60863 + }, + "inputs": [] + }, + { + "id": "e1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e1: EcxOperand", + "range": { + "start": 60868, + "end": 60902 + }, + "inputs": [] + }, + { + "id": "from", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "from: EcxOperand", + "range": { + "start": 60907, + "end": 60943 + }, + "inputs": [] + }, + { + "id": "new_from", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "new_from: EcxExpr", + "range": { + "start": 60948, + "end": 60985 + }, + "inputs": [] + }, + { + "id": "to", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "to: EcxOperand", + "range": { + "start": 60990, + "end": 61024 + }, + "inputs": [] + }, + { + "id": "kw_type", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "kw_type: EcxType", + "range": { + "start": 61029, + "end": 61065 + }, + "inputs": [] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "Ecxcan_subst_Operand_beneath", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "range": { + "start": 61070, + "end": 61138 + }, + "inputs": [ + "above", + "from", + "to" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxbadd", + "label": "_t2: Ecxbadd", + "range": { + "start": 61143, + "end": 61190 + }, + "inputs": [ + "kw_type", + "e1", + "from" + ] + } + ], + "edges": [ + { + "from": "_rel1", + "to": "above", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel1", + "to": "to", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "kw_type", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "e1", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "from", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "above", + "e1", + "from", + "new_from", + "to", + "kw_type", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "new_from.handle().eq(&_t2.handle())", + "semantic_text": "new_from == _t2", + "referenced_vars": [ + "_t2", + "new_from" + ], + "range": { + "start": 61317, + "end": 61319 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@205647:205694", + "bound_var": "t2", + "source_text": "ctx.insert_ecxbadd(pat.kw_type, pat.e1, pat.to)", + "semantic_text": null, + "referenced_pat_vars": [ + "e1", + "kw_type", + "to" + ], + "referenced_action_vars": [], + "range": { + "start": 205647, + "end": 205694 + } + }, + { + "id": "effect_1", + "effect_id": "effect@205715:205780", + "bound_var": "rel1", + "source_text": "ctx.insert_ecxcan_subst_expr_beneath(pat.above, pat.new_from, t2)", + "semantic_text": null, + "referenced_pat_vars": [ + "above", + "new_from" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 205715, + "end": 205780 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0061", + "premises": [ + { + "target_id": "_rel1", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "plain_source": "upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxbadd", + "plain_source": "upright(\"badd\")(upright(\"kw_type\"), e_1, upright(\"from\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $]) $]" + } + ], + "side_conditions": [ + "upright(\"new_from\") == upright(\"_t2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"badd\")(upright(\"kw_type\"), e_1, upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"badd\")(upright(\"kw_type\"), e_1, upright(\"to\")))", + "colored_source": "upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"badd\")(upright(\"kw_type\"), e_1, upright(\"to\")))", + "colored_source": "upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\")) \\ upright(\"badd\")(upright(\"kw_type\"), e_1, upright(\"from\")), upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"badd\")(upright(\"kw_type\"), e_1, upright(\"to\")))) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $]) $], upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $])) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6835_5_MyTxEggccExtraction_add_rule__r0062__bc4a93dbd658bd47", + "display_name": "r0062", + "rule_name": "r0062", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 205794, + "line": 6835, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 205794, + "end": 206024 + }, + "pattern_range": { + "start": 205840, + "end": 205851 + }, + "action_range": { + "start": 205853, + "end": 206023 + } + }, + "nodes": [ + { + "id": "above", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "above: EcxBody", + "range": { + "start": 61620, + "end": 61654 + }, + "inputs": [] + }, + { + "id": "e2", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e2: EcxOperand", + "range": { + "start": 61659, + "end": 61693 + }, + "inputs": [] + }, + { + "id": "from", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "from: EcxOperand", + "range": { + "start": 61698, + "end": 61734 + }, + "inputs": [] + }, + { + "id": "new_from", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "new_from: EcxExpr", + "range": { + "start": 61739, + "end": 61776 + }, + "inputs": [] + }, + { + "id": "to", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "to: EcxOperand", + "range": { + "start": 61781, + "end": 61815 + }, + "inputs": [] + }, + { + "id": "kw_type", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "kw_type: EcxType", + "range": { + "start": 61820, + "end": 61856 + }, + "inputs": [] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "Ecxcan_subst_Operand_beneath", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "range": { + "start": 61861, + "end": 61929 + }, + "inputs": [ + "above", + "from", + "to" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxbsub", + "label": "_t2: Ecxbsub", + "range": { + "start": 61934, + "end": 61981 + }, + "inputs": [ + "kw_type", + "from", + "e2" + ] + } + ], + "edges": [ + { + "from": "_rel1", + "to": "above", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel1", + "to": "to", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "kw_type", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "e2", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "above", + "e2", + "from", + "new_from", + "to", + "kw_type", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "new_from.handle().eq(&_t2.handle())", + "semantic_text": "new_from == _t2", + "referenced_vars": [ + "_t2", + "new_from" + ], + "range": { + "start": 62108, + "end": 62110 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@205883:205930", + "bound_var": "t2", + "source_text": "ctx.insert_ecxbsub(pat.kw_type, pat.to, pat.e2)", + "semantic_text": null, + "referenced_pat_vars": [ + "e2", + "kw_type", + "to" + ], + "referenced_action_vars": [], + "range": { + "start": 205883, + "end": 205930 + } + }, + { + "id": "effect_1", + "effect_id": "effect@205951:206016", + "bound_var": "rel1", + "source_text": "ctx.insert_ecxcan_subst_expr_beneath(pat.above, pat.new_from, t2)", + "semantic_text": null, + "referenced_pat_vars": [ + "above", + "new_from" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 205951, + "end": 206016 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0062", + "premises": [ + { + "target_id": "_rel1", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "plain_source": "upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxbsub", + "plain_source": "upright(\"bsub\")(upright(\"kw_type\"), upright(\"from\"), e_2)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $]" + } + ], + "side_conditions": [ + "upright(\"new_from\") == upright(\"_t2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"bsub\")(upright(\"kw_type\"), upright(\"to\"), e_2)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"bsub\")(upright(\"kw_type\"), upright(\"to\"), e_2))", + "colored_source": "upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"bsub\")(upright(\"kw_type\"), upright(\"to\"), e_2))", + "colored_source": "upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\")) \\ upright(\"bsub\")(upright(\"kw_type\"), upright(\"from\"), e_2), upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"bsub\")(upright(\"kw_type\"), upright(\"to\"), e_2))) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $], upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $])) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6839_5_MyTxEggccExtraction_add_rule__r0063__c936077969948400", + "display_name": "r0063", + "rule_name": "r0063", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 206030, + "line": 6839, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 206030, + "end": 206260 + }, + "pattern_range": { + "start": 206076, + "end": 206087 + }, + "action_range": { + "start": 206089, + "end": 206259 + } + }, + "nodes": [ + { + "id": "above", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "above: EcxBody", + "range": { + "start": 62411, + "end": 62445 + }, + "inputs": [] + }, + { + "id": "e1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e1: EcxOperand", + "range": { + "start": 62450, + "end": 62484 + }, + "inputs": [] + }, + { + "id": "from", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "from: EcxOperand", + "range": { + "start": 62489, + "end": 62525 + }, + "inputs": [] + }, + { + "id": "new_from", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "new_from: EcxExpr", + "range": { + "start": 62530, + "end": 62567 + }, + "inputs": [] + }, + { + "id": "to", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "to: EcxOperand", + "range": { + "start": 62572, + "end": 62606 + }, + "inputs": [] + }, + { + "id": "kw_type", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "kw_type: EcxType", + "range": { + "start": 62611, + "end": 62647 + }, + "inputs": [] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "Ecxcan_subst_Operand_beneath", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "range": { + "start": 62652, + "end": 62720 + }, + "inputs": [ + "above", + "from", + "to" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxbsub", + "label": "_t2: Ecxbsub", + "range": { + "start": 62725, + "end": 62772 + }, + "inputs": [ + "kw_type", + "e1", + "from" + ] + } + ], + "edges": [ + { + "from": "_rel1", + "to": "above", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel1", + "to": "to", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "kw_type", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "e1", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "from", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "above", + "e1", + "from", + "new_from", + "to", + "kw_type", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "new_from.handle().eq(&_t2.handle())", + "semantic_text": "new_from == _t2", + "referenced_vars": [ + "_t2", + "new_from" + ], + "range": { + "start": 62899, + "end": 62901 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@206119:206166", + "bound_var": "t2", + "source_text": "ctx.insert_ecxbsub(pat.kw_type, pat.e1, pat.to)", + "semantic_text": null, + "referenced_pat_vars": [ + "e1", + "kw_type", + "to" + ], + "referenced_action_vars": [], + "range": { + "start": 206119, + "end": 206166 + } + }, + { + "id": "effect_1", + "effect_id": "effect@206187:206252", + "bound_var": "rel1", + "source_text": "ctx.insert_ecxcan_subst_expr_beneath(pat.above, pat.new_from, t2)", + "semantic_text": null, + "referenced_pat_vars": [ + "above", + "new_from" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 206187, + "end": 206252 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0063", + "premises": [ + { + "target_id": "_rel1", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "plain_source": "upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxbsub", + "plain_source": "upright(\"bsub\")(upright(\"kw_type\"), e_1, upright(\"from\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $]) $]" + } + ], + "side_conditions": [ + "upright(\"new_from\") == upright(\"_t2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"bsub\")(upright(\"kw_type\"), e_1, upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"bsub\")(upright(\"kw_type\"), e_1, upright(\"to\")))", + "colored_source": "upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"bsub\")(upright(\"kw_type\"), e_1, upright(\"to\")))", + "colored_source": "upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\")) \\ upright(\"bsub\")(upright(\"kw_type\"), e_1, upright(\"from\")), upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"bsub\")(upright(\"kw_type\"), e_1, upright(\"to\")))) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $]) $], upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $])) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6843_5_MyTxEggccExtraction_add_rule__r0064__41daed39bc87f0a8", + "display_name": "r0064", + "rule_name": "r0064", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 206266, + "line": 6843, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 206266, + "end": 206496 + }, + "pattern_range": { + "start": 206312, + "end": 206323 + }, + "action_range": { + "start": 206325, + "end": 206495 + } + }, + "nodes": [ + { + "id": "above", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "above: EcxBody", + "range": { + "start": 63202, + "end": 63236 + }, + "inputs": [] + }, + { + "id": "e2", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e2: EcxOperand", + "range": { + "start": 63241, + "end": 63275 + }, + "inputs": [] + }, + { + "id": "from", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "from: EcxOperand", + "range": { + "start": 63280, + "end": 63316 + }, + "inputs": [] + }, + { + "id": "new_from", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "new_from: EcxExpr", + "range": { + "start": 63321, + "end": 63358 + }, + "inputs": [] + }, + { + "id": "to", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "to: EcxOperand", + "range": { + "start": 63363, + "end": 63397 + }, + "inputs": [] + }, + { + "id": "kw_type", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "kw_type: EcxType", + "range": { + "start": 63402, + "end": 63438 + }, + "inputs": [] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "Ecxcan_subst_Operand_beneath", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "range": { + "start": 63443, + "end": 63511 + }, + "inputs": [ + "above", + "from", + "to" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxbmul", + "label": "_t2: Ecxbmul", + "range": { + "start": 63516, + "end": 63563 + }, + "inputs": [ + "kw_type", + "from", + "e2" + ] + } + ], + "edges": [ + { + "from": "_rel1", + "to": "above", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel1", + "to": "to", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "kw_type", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "e2", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "above", + "e2", + "from", + "new_from", + "to", + "kw_type", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "new_from.handle().eq(&_t2.handle())", + "semantic_text": "new_from == _t2", + "referenced_vars": [ + "_t2", + "new_from" + ], + "range": { + "start": 63690, + "end": 63692 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@206355:206402", + "bound_var": "t2", + "source_text": "ctx.insert_ecxbmul(pat.kw_type, pat.to, pat.e2)", + "semantic_text": null, + "referenced_pat_vars": [ + "e2", + "kw_type", + "to" + ], + "referenced_action_vars": [], + "range": { + "start": 206355, + "end": 206402 + } + }, + { + "id": "effect_1", + "effect_id": "effect@206423:206488", + "bound_var": "rel1", + "source_text": "ctx.insert_ecxcan_subst_expr_beneath(pat.above, pat.new_from, t2)", + "semantic_text": null, + "referenced_pat_vars": [ + "above", + "new_from" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 206423, + "end": 206488 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0064", + "premises": [ + { + "target_id": "_rel1", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "plain_source": "upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxbmul", + "plain_source": "upright(\"bmul\")(upright(\"kw_type\"), upright(\"from\"), e_2)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $]" + } + ], + "side_conditions": [ + "upright(\"new_from\") == upright(\"_t2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"bmul\")(upright(\"kw_type\"), upright(\"to\"), e_2)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"bmul\")(upright(\"kw_type\"), upright(\"to\"), e_2))", + "colored_source": "upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"bmul\")(upright(\"kw_type\"), upright(\"to\"), e_2))", + "colored_source": "upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\")) \\ upright(\"bmul\")(upright(\"kw_type\"), upright(\"from\"), e_2), upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"bmul\")(upright(\"kw_type\"), upright(\"to\"), e_2))) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $], upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $])) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6847_5_MyTxEggccExtraction_add_rule__r0065__d2f07303bfe6ce57", + "display_name": "r0065", + "rule_name": "r0065", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 206502, + "line": 6847, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 206502, + "end": 206732 + }, + "pattern_range": { + "start": 206548, + "end": 206559 + }, + "action_range": { + "start": 206561, + "end": 206731 + } + }, + "nodes": [ + { + "id": "above", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "above: EcxBody", + "range": { + "start": 63993, + "end": 64027 + }, + "inputs": [] + }, + { + "id": "e1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e1: EcxOperand", + "range": { + "start": 64032, + "end": 64066 + }, + "inputs": [] + }, + { + "id": "from", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "from: EcxOperand", + "range": { + "start": 64071, + "end": 64107 + }, + "inputs": [] + }, + { + "id": "new_from", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "new_from: EcxExpr", + "range": { + "start": 64112, + "end": 64149 + }, + "inputs": [] + }, + { + "id": "to", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "to: EcxOperand", + "range": { + "start": 64154, + "end": 64188 + }, + "inputs": [] + }, + { + "id": "kw_type", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "kw_type: EcxType", + "range": { + "start": 64193, + "end": 64229 + }, + "inputs": [] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "Ecxcan_subst_Operand_beneath", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "range": { + "start": 64234, + "end": 64302 + }, + "inputs": [ + "above", + "from", + "to" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxbmul", + "label": "_t2: Ecxbmul", + "range": { + "start": 64307, + "end": 64354 + }, + "inputs": [ + "kw_type", + "e1", + "from" + ] + } + ], + "edges": [ + { + "from": "_rel1", + "to": "above", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel1", + "to": "to", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "kw_type", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "e1", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "from", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "above", + "e1", + "from", + "new_from", + "to", + "kw_type", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "new_from.handle().eq(&_t2.handle())", + "semantic_text": "new_from == _t2", + "referenced_vars": [ + "_t2", + "new_from" + ], + "range": { + "start": 64481, + "end": 64483 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@206591:206638", + "bound_var": "t2", + "source_text": "ctx.insert_ecxbmul(pat.kw_type, pat.e1, pat.to)", + "semantic_text": null, + "referenced_pat_vars": [ + "e1", + "kw_type", + "to" + ], + "referenced_action_vars": [], + "range": { + "start": 206591, + "end": 206638 + } + }, + { + "id": "effect_1", + "effect_id": "effect@206659:206724", + "bound_var": "rel1", + "source_text": "ctx.insert_ecxcan_subst_expr_beneath(pat.above, pat.new_from, t2)", + "semantic_text": null, + "referenced_pat_vars": [ + "above", + "new_from" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 206659, + "end": 206724 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0065", + "premises": [ + { + "target_id": "_rel1", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "plain_source": "upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxbmul", + "plain_source": "upright(\"bmul\")(upright(\"kw_type\"), e_1, upright(\"from\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $]) $]" + } + ], + "side_conditions": [ + "upright(\"new_from\") == upright(\"_t2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"bmul\")(upright(\"kw_type\"), e_1, upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"bmul\")(upright(\"kw_type\"), e_1, upright(\"to\")))", + "colored_source": "upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"bmul\")(upright(\"kw_type\"), e_1, upright(\"to\")))", + "colored_source": "upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\")) \\ upright(\"bmul\")(upright(\"kw_type\"), e_1, upright(\"from\")), upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"bmul\")(upright(\"kw_type\"), e_1, upright(\"to\")))) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $]) $], upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $])) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6851_5_MyTxEggccExtraction_add_rule__r0066__74dbe6056c25d71d", + "display_name": "r0066", + "rule_name": "r0066", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 206738, + "line": 6851, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 206738, + "end": 206968 + }, + "pattern_range": { + "start": 206784, + "end": 206795 + }, + "action_range": { + "start": 206797, + "end": 206967 + } + }, + "nodes": [ + { + "id": "above", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "above: EcxBody", + "range": { + "start": 64784, + "end": 64818 + }, + "inputs": [] + }, + { + "id": "e2", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e2: EcxOperand", + "range": { + "start": 64823, + "end": 64857 + }, + "inputs": [] + }, + { + "id": "from", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "from: EcxOperand", + "range": { + "start": 64862, + "end": 64898 + }, + "inputs": [] + }, + { + "id": "new_from", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "new_from: EcxExpr", + "range": { + "start": 64903, + "end": 64940 + }, + "inputs": [] + }, + { + "id": "to", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "to: EcxOperand", + "range": { + "start": 64945, + "end": 64979 + }, + "inputs": [] + }, + { + "id": "kw_type", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "kw_type: EcxType", + "range": { + "start": 64984, + "end": 65020 + }, + "inputs": [] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "Ecxcan_subst_Operand_beneath", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "range": { + "start": 65025, + "end": 65093 + }, + "inputs": [ + "above", + "from", + "to" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxbdiv", + "label": "_t2: Ecxbdiv", + "range": { + "start": 65098, + "end": 65145 + }, + "inputs": [ + "kw_type", + "from", + "e2" + ] + } + ], + "edges": [ + { + "from": "_rel1", + "to": "above", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel1", + "to": "to", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "kw_type", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "e2", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "above", + "e2", + "from", + "new_from", + "to", + "kw_type", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "new_from.handle().eq(&_t2.handle())", + "semantic_text": "new_from == _t2", + "referenced_vars": [ + "_t2", + "new_from" + ], + "range": { + "start": 65272, + "end": 65274 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@206827:206874", + "bound_var": "t2", + "source_text": "ctx.insert_ecxbdiv(pat.kw_type, pat.to, pat.e2)", + "semantic_text": null, + "referenced_pat_vars": [ + "e2", + "kw_type", + "to" + ], + "referenced_action_vars": [], + "range": { + "start": 206827, + "end": 206874 + } + }, + { + "id": "effect_1", + "effect_id": "effect@206895:206960", + "bound_var": "rel1", + "source_text": "ctx.insert_ecxcan_subst_expr_beneath(pat.above, pat.new_from, t2)", + "semantic_text": null, + "referenced_pat_vars": [ + "above", + "new_from" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 206895, + "end": 206960 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0066", + "premises": [ + { + "target_id": "_rel1", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "plain_source": "upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxbdiv", + "plain_source": "upright(\"bdiv\")(upright(\"kw_type\"), upright(\"from\"), e_2)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $]" + } + ], + "side_conditions": [ + "upright(\"new_from\") == upright(\"_t2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"bdiv\")(upright(\"kw_type\"), upright(\"to\"), e_2)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"bdiv\")(upright(\"kw_type\"), upright(\"to\"), e_2))", + "colored_source": "upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"bdiv\")(upright(\"kw_type\"), upright(\"to\"), e_2))", + "colored_source": "upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\")) \\ upright(\"bdiv\")(upright(\"kw_type\"), upright(\"from\"), e_2), upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"bdiv\")(upright(\"kw_type\"), upright(\"to\"), e_2))) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $], upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $])) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6855_5_MyTxEggccExtraction_add_rule__r0067__217e766a3f69e0a6", + "display_name": "r0067", + "rule_name": "r0067", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 206974, + "line": 6855, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 206974, + "end": 207204 + }, + "pattern_range": { + "start": 207020, + "end": 207031 + }, + "action_range": { + "start": 207033, + "end": 207203 + } + }, + "nodes": [ + { + "id": "above", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "above: EcxBody", + "range": { + "start": 65575, + "end": 65609 + }, + "inputs": [] + }, + { + "id": "e1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e1: EcxOperand", + "range": { + "start": 65614, + "end": 65648 + }, + "inputs": [] + }, + { + "id": "from", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "from: EcxOperand", + "range": { + "start": 65653, + "end": 65689 + }, + "inputs": [] + }, + { + "id": "new_from", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "new_from: EcxExpr", + "range": { + "start": 65694, + "end": 65731 + }, + "inputs": [] + }, + { + "id": "to", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "to: EcxOperand", + "range": { + "start": 65736, + "end": 65770 + }, + "inputs": [] + }, + { + "id": "kw_type", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "kw_type: EcxType", + "range": { + "start": 65775, + "end": 65811 + }, + "inputs": [] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "Ecxcan_subst_Operand_beneath", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "range": { + "start": 65816, + "end": 65884 + }, + "inputs": [ + "above", + "from", + "to" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxbdiv", + "label": "_t2: Ecxbdiv", + "range": { + "start": 65889, + "end": 65936 + }, + "inputs": [ + "kw_type", + "e1", + "from" + ] + } + ], + "edges": [ + { + "from": "_rel1", + "to": "above", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel1", + "to": "to", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "kw_type", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "e1", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "from", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "above", + "e1", + "from", + "new_from", + "to", + "kw_type", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "new_from.handle().eq(&_t2.handle())", + "semantic_text": "new_from == _t2", + "referenced_vars": [ + "_t2", + "new_from" + ], + "range": { + "start": 66063, + "end": 66065 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@207063:207110", + "bound_var": "t2", + "source_text": "ctx.insert_ecxbdiv(pat.kw_type, pat.e1, pat.to)", + "semantic_text": null, + "referenced_pat_vars": [ + "e1", + "kw_type", + "to" + ], + "referenced_action_vars": [], + "range": { + "start": 207063, + "end": 207110 + } + }, + { + "id": "effect_1", + "effect_id": "effect@207131:207196", + "bound_var": "rel1", + "source_text": "ctx.insert_ecxcan_subst_expr_beneath(pat.above, pat.new_from, t2)", + "semantic_text": null, + "referenced_pat_vars": [ + "above", + "new_from" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 207131, + "end": 207196 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0067", + "premises": [ + { + "target_id": "_rel1", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "plain_source": "upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxbdiv", + "plain_source": "upright(\"bdiv\")(upright(\"kw_type\"), e_1, upright(\"from\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $]) $]" + } + ], + "side_conditions": [ + "upright(\"new_from\") == upright(\"_t2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"bdiv\")(upright(\"kw_type\"), e_1, upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"bdiv\")(upright(\"kw_type\"), e_1, upright(\"to\")))", + "colored_source": "upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"bdiv\")(upright(\"kw_type\"), e_1, upright(\"to\")))", + "colored_source": "upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\")) \\ upright(\"bdiv\")(upright(\"kw_type\"), e_1, upright(\"from\")), upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"bdiv\")(upright(\"kw_type\"), e_1, upright(\"to\")))) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $]) $], upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $])) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6859_5_MyTxEggccExtraction_add_rule__r0068__e55bbd684197ccfb", + "display_name": "r0068", + "rule_name": "r0068", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 207210, + "line": 6859, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 207210, + "end": 207439 + }, + "pattern_range": { + "start": 207256, + "end": 207267 + }, + "action_range": { + "start": 207269, + "end": 207438 + } + }, + "nodes": [ + { + "id": "above", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "above: EcxBody", + "range": { + "start": 66365, + "end": 66399 + }, + "inputs": [] + }, + { + "id": "e2", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e2: EcxOperand", + "range": { + "start": 66404, + "end": 66438 + }, + "inputs": [] + }, + { + "id": "from", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "from: EcxOperand", + "range": { + "start": 66443, + "end": 66479 + }, + "inputs": [] + }, + { + "id": "new_from", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "new_from: EcxExpr", + "range": { + "start": 66484, + "end": 66521 + }, + "inputs": [] + }, + { + "id": "to", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "to: EcxOperand", + "range": { + "start": 66526, + "end": 66560 + }, + "inputs": [] + }, + { + "id": "kw_type", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "kw_type: EcxType", + "range": { + "start": 66565, + "end": 66601 + }, + "inputs": [] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "Ecxcan_subst_Operand_beneath", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "range": { + "start": 66606, + "end": 66674 + }, + "inputs": [ + "above", + "from", + "to" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxblt", + "label": "_t2: Ecxblt", + "range": { + "start": 66679, + "end": 66725 + }, + "inputs": [ + "kw_type", + "from", + "e2" + ] + } + ], + "edges": [ + { + "from": "_rel1", + "to": "above", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel1", + "to": "to", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "kw_type", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "e2", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "above", + "e2", + "from", + "new_from", + "to", + "kw_type", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "new_from.handle().eq(&_t2.handle())", + "semantic_text": "new_from == _t2", + "referenced_vars": [ + "_t2", + "new_from" + ], + "range": { + "start": 66852, + "end": 66854 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@207299:207345", + "bound_var": "t2", + "source_text": "ctx.insert_ecxblt(pat.kw_type, pat.to, pat.e2)", + "semantic_text": null, + "referenced_pat_vars": [ + "e2", + "kw_type", + "to" + ], + "referenced_action_vars": [], + "range": { + "start": 207299, + "end": 207345 + } + }, + { + "id": "effect_1", + "effect_id": "effect@207366:207431", + "bound_var": "rel1", + "source_text": "ctx.insert_ecxcan_subst_expr_beneath(pat.above, pat.new_from, t2)", + "semantic_text": null, + "referenced_pat_vars": [ + "above", + "new_from" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 207366, + "end": 207431 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0068", + "premises": [ + { + "target_id": "_rel1", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "plain_source": "upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxblt", + "plain_source": "upright(\"blt\")(upright(\"kw_type\"), upright(\"from\"), e_2)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $]" + } + ], + "side_conditions": [ + "upright(\"new_from\") == upright(\"_t2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"blt\")(upright(\"kw_type\"), upright(\"to\"), e_2)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"blt\")(upright(\"kw_type\"), upright(\"to\"), e_2))", + "colored_source": "upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"blt\")(upright(\"kw_type\"), upright(\"to\"), e_2))", + "colored_source": "upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\")) \\ upright(\"blt\")(upright(\"kw_type\"), upright(\"from\"), e_2), upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"blt\")(upright(\"kw_type\"), upright(\"to\"), e_2))) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $], upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_2 $]) $])) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6863_5_MyTxEggccExtraction_add_rule__r0069__c96c185590cc393d", + "display_name": "r0069", + "rule_name": "r0069", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 207445, + "line": 6863, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 207445, + "end": 207674 + }, + "pattern_range": { + "start": 207491, + "end": 207502 + }, + "action_range": { + "start": 207504, + "end": 207673 + } + }, + "nodes": [ + { + "id": "above", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "above: EcxBody", + "range": { + "start": 67154, + "end": 67188 + }, + "inputs": [] + }, + { + "id": "e1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "e1: EcxOperand", + "range": { + "start": 67193, + "end": 67227 + }, + "inputs": [] + }, + { + "id": "from", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "from: EcxOperand", + "range": { + "start": 67232, + "end": 67268 + }, + "inputs": [] + }, + { + "id": "new_from", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "new_from: EcxExpr", + "range": { + "start": 67273, + "end": 67310 + }, + "inputs": [] + }, + { + "id": "to", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "to: EcxOperand", + "range": { + "start": 67315, + "end": 67349 + }, + "inputs": [] + }, + { + "id": "kw_type", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "kw_type: EcxType", + "range": { + "start": 67354, + "end": 67390 + }, + "inputs": [] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "Ecxcan_subst_Operand_beneath", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "range": { + "start": 67395, + "end": 67463 + }, + "inputs": [ + "above", + "from", + "to" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxblt", + "label": "_t2: Ecxblt", + "range": { + "start": 67468, + "end": 67514 + }, + "inputs": [ + "kw_type", + "e1", + "from" + ] + } + ], + "edges": [ + { + "from": "_rel1", + "to": "above", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel1", + "to": "to", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "kw_type", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "e1", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "from", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "above", + "e1", + "from", + "new_from", + "to", + "kw_type", + "_rel1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "new_from.handle().eq(&_t2.handle())", + "semantic_text": "new_from == _t2", + "referenced_vars": [ + "_t2", + "new_from" + ], + "range": { + "start": 67641, + "end": 67643 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@207534:207580", + "bound_var": "t2", + "source_text": "ctx.insert_ecxblt(pat.kw_type, pat.e1, pat.to)", + "semantic_text": null, + "referenced_pat_vars": [ + "e1", + "kw_type", + "to" + ], + "referenced_action_vars": [], + "range": { + "start": 207534, + "end": 207580 + } + }, + { + "id": "effect_1", + "effect_id": "effect@207601:207666", + "bound_var": "rel1", + "source_text": "ctx.insert_ecxcan_subst_expr_beneath(pat.above, pat.new_from, t2)", + "semantic_text": null, + "referenced_pat_vars": [ + "above", + "new_from" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 207601, + "end": 207666 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0069", + "premises": [ + { + "target_id": "_rel1", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "plain_source": "upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxblt", + "plain_source": "upright(\"blt\")(upright(\"kw_type\"), e_1, upright(\"from\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $]) $]" + } + ], + "side_conditions": [ + "upright(\"new_from\") == upright(\"_t2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"blt\")(upright(\"kw_type\"), e_1, upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"blt\")(upright(\"kw_type\"), e_1, upright(\"to\")))", + "colored_source": "upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"blt\")(upright(\"kw_type\"), e_1, upright(\"to\")))", + "colored_source": "upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\")) \\ upright(\"blt\")(upright(\"kw_type\"), e_1, upright(\"from\")), upright(\"EcxcanSubstExprBeneath\")(upright(\"above\"), upright(\"new_from\"), upright(\"blt\")(upright(\"kw_type\"), e_1, upright(\"to\")))) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $]) $], upright(\"EcxcanSubstExprBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_from\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_type\") $], #text(fill: rgb(\"#5F7A8A\"))[$ e_1 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $])) quad upright(\"if\") quad upright(\"new_from\") == upright(\"_t2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6867_5_MyTxEggccExtraction_add_rule__r0070__dd410504953b71a7", + "display_name": "r0070", + "rule_name": "r0070", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 207680, + "line": 6867, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 207680, + "end": 208191 + }, + "pattern_range": { + "start": 207726, + "end": 207737 + }, + "action_range": { + "start": 207739, + "end": 208190 + } + }, + "nodes": [ + { + "id": "above", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "above: EcxBody", + "range": { + "start": 67945, + "end": 67979 + }, + "inputs": [] + }, + { + "id": "from", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "from: EcxOperand", + "range": { + "start": 67984, + "end": 68020 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 68025, + "end": 68070 + }, + "inputs": [] + }, + { + "id": "to", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "to: EcxOperand", + "range": { + "start": 68075, + "end": 68109 + }, + "inputs": [] + }, + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "vec: EcxVecOperandBase", + "range": { + "start": 68114, + "end": 68156 + }, + "inputs": [] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "Ecxcan_subst_Operand_beneath", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "range": { + "start": 68161, + "end": 68229 + }, + "inputs": [ + "above", + "from", + "to" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t3: EcxVO", + "range": { + "start": 68234, + "end": 68263 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVecOperand_get", + "label": "_t2: EcxVecOperand_get", + "range": { + "start": 68268, + "end": 68309 + }, + "inputs": [ + "_t3" + ] + } + ], + "edges": [ + { + "from": "_rel1", + "to": "above", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel1", + "to": "to", + "kind": "operand", + "index": 2 + }, + { + "from": "_t3", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "_t3", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "above", + "from", + "i", + "to", + "vec", + "_rel1", + "_t2", + "_t3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_t2.handle_a1())", + "semantic_text": "i == _t2.a1", + "referenced_vars": [ + "_t2", + "i" + ], + "range": { + "start": 68477, + "end": 68479 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "from.handle().eq(&_t2.handle())", + "semantic_text": "from == _t2", + "referenced_vars": [ + "_t2", + "from" + ], + "range": { + "start": 68497, + "end": 68499 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@207769:207795", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_vo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 207769, + "end": 207795 + } + }, + { + "id": "effect_1", + "effect_id": "effect@207814:208100", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_vo(\n ctx.intern_container::>(vec_set::<\n EcxOperand,\n >(\n &*ctx.devalue(pat.vec),\n ctx.devalue(pat.i),\n pat.to.erase(),\n )),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "i", + "to", + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 207814, + "end": 208100 + } + }, + { + "id": "effect_2", + "effect_id": "effect@208121:208183", + "bound_var": "rel1", + "source_text": "ctx.insert_ecxcan_subst_vec_operand_beneath(pat.above, t2, t3)", + "semantic_text": null, + "referenced_pat_vars": [ + "above" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 208121, + "end": 208183 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0070", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_rel1", + "label": "_rel1: Ecxcan_subst_Operand_beneath", + "plain_source": "upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVecOperand_get", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + } + ], + "side_conditions": [ + "i == upright(\"_t2.a1\")", + "upright(\"from\") == upright(\"_t2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"EcxVo\")(upright(\"vec\"))", + "colored_source": "upright(\"EcxVo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $])" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"EcxVo\")(upright(\"intern_container\")::>(upright(\"vec_set\")::< upright(\"EcxOperand\"), >(*upright(\"vec\"), i, upright(\"to.erase\")())))", + "colored_source": "upright(\"EcxVo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"vec_set\")::< upright(\"EcxOperand\"), >(*upright(\"vec\"), i, upright(\"to.erase\")())) $])" + }, + { + "target_id": "effect:effect_2", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstVecOperandBeneath\")(upright(\"above\"), upright(\"EcxVo\")(upright(\"vec\")), upright(\"EcxVo\")(upright(\"intern_container\")::>(upright(\"vec_set\")::< upright(\"EcxOperand\"), >(*upright(\"vec\"), i, upright(\"to.erase\")()))))", + "colored_source": "upright(\"EcxcanSubstVecOperandBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], upright(\"EcxVo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]), upright(\"EcxVo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"vec_set\")::< upright(\"EcxOperand\"), >(*upright(\"vec\"), i, upright(\"to.erase\")())) $]))" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_2", + "entry": { + "target_id": "effect:effect_2", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstVecOperandBeneath\")(upright(\"above\"), upright(\"EcxVo\")(upright(\"vec\")), upright(\"EcxVo\")(upright(\"intern_container\")::>(upright(\"vec_set\")::< upright(\"EcxOperand\"), >(*upright(\"vec\"), i, upright(\"to.erase\")()))))", + "colored_source": "upright(\"EcxcanSubstVecOperandBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], upright(\"EcxVo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]), upright(\"EcxVo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"vec_set\")::< upright(\"EcxOperand\"), >(*upright(\"vec\"), i, upright(\"to.erase\")())) $]))" + } + } + ], + "formula_source": { + "plain": "frac(i \\ upright(\"can_subst_Operand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\")) \\ upright(\"_t2\") \\ upright(\"VO\")(upright(\"vec\")), upright(\"EcxcanSubstVecOperandBeneath\")(upright(\"above\"), upright(\"EcxVo\")(upright(\"vec\")), upright(\"EcxVo\")(upright(\"intern_container\")::>(upright(\"vec_set\")::< upright(\"EcxOperand\"), >(*upright(\"vec\"), i, upright(\"to.erase\")()))))) quad upright(\"if\") quad i == upright(\"_t2.a1\") \\ upright(\"from\") == upright(\"_t2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_Operand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], upright(\"EcxcanSubstVecOperandBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], upright(\"EcxVo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]), upright(\"EcxVo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"vec_set\")::< upright(\"EcxOperand\"), >(*upright(\"vec\"), i, upright(\"to.erase\")())) $]))) quad upright(\"if\") quad i == upright(\"_t2.a1\") \\ upright(\"from\") == upright(\"_t2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6880_5_MyTxEggccExtraction_add_rule__r0071__144f4cadff73f50b", + "display_name": "r0071", + "rule_name": "r0071", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 208197, + "line": 6880, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 208197, + "end": 208723 + }, + "pattern_range": { + "start": 208243, + "end": 208254 + }, + "action_range": { + "start": 208256, + "end": 208722 + } + }, + "nodes": [ + { + "id": "above", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "above: EcxBody", + "range": { + "start": 68817, + "end": 68851 + }, + "inputs": [] + }, + { + "id": "from", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "from: EcxVecOperand", + "range": { + "start": 68856, + "end": 68895 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 68900, + "end": 68945 + }, + "inputs": [] + }, + { + "id": "to", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "to: EcxVecOperand", + "range": { + "start": 68950, + "end": 68987 + }, + "inputs": [] + }, + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperandBase", + "label": "vec: EcxVecVecOperandBase", + "range": { + "start": 68992, + "end": 69037 + }, + "inputs": [] + }, + { + "id": "_rel1", + "kind": "query", + "dsl_type": "Ecxcan_subst_VecOperand_beneath", + "label": "_rel1: Ecxcan_subst_VecOperand_beneath", + "range": { + "start": 69042, + "end": 69113 + }, + "inputs": [ + "above", + "from", + "to" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t3: EcxVVO", + "range": { + "start": 69118, + "end": 69148 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVecVecOperand_get", + "label": "_t2: EcxVecVecOperand_get", + "range": { + "start": 69153, + "end": 69197 + }, + "inputs": [ + "_t3" + ] + } + ], + "edges": [ + { + "from": "_rel1", + "to": "above", + "kind": "operand", + "index": 0 + }, + { + "from": "_rel1", + "to": "from", + "kind": "operand", + "index": 1 + }, + { + "from": "_rel1", + "to": "to", + "kind": "operand", + "index": 2 + }, + { + "from": "_t3", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "_t3", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "above", + "from", + "i", + "to", + "vec", + "_rel1", + "_t2", + "_t3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_t2.handle_a1())", + "semantic_text": "i == _t2.a1", + "referenced_vars": [ + "_t2", + "i" + ], + "range": { + "start": 69365, + "end": 69367 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "from.handle().eq(&_t2.handle())", + "semantic_text": "from == _t2", + "referenced_vars": [ + "_t2", + "from" + ], + "range": { + "start": 69385, + "end": 69387 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@208286:208313", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_vvo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 208286, + "end": 208313 + } + }, + { + "id": "effect_1", + "effect_id": "effect@208332:208628", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_vvo(\n ctx.intern_container::>(vec_set::<\n EcxVecOperand,\n >(\n &*ctx.devalue(pat.vec),\n ctx.devalue(pat.i),\n pat.to.erase(),\n )),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "i", + "to", + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 208332, + "end": 208628 + } + }, + { + "id": "effect_2", + "effect_id": "effect@208649:208715", + "bound_var": "rel1", + "source_text": "ctx.insert_ecxcan_subst_vec_vec_operand_beneath(pat.above, t2, t3)", + "semantic_text": null, + "referenced_pat_vars": [ + "above" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 208649, + "end": 208715 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0071", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_rel1", + "label": "_rel1: Ecxcan_subst_VecOperand_beneath", + "plain_source": "upright(\"can_subst_VecOperand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_VecOperand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVecVecOperand_get", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + } + ], + "side_conditions": [ + "i == upright(\"_t2.a1\")", + "upright(\"from\") == upright(\"_t2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"EcxVvo\")(upright(\"vec\"))", + "colored_source": "upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $])" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"EcxVvo\")(upright(\"intern_container\")::>(upright(\"vec_set\")::< upright(\"EcxVecOperand\"), >(*upright(\"vec\"), i, upright(\"to.erase\")())))", + "colored_source": "upright(\"EcxVvo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"vec_set\")::< upright(\"EcxVecOperand\"), >(*upright(\"vec\"), i, upright(\"to.erase\")())) $])" + }, + { + "target_id": "effect:effect_2", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstVecVecOperandBeneath\")(upright(\"above\"), upright(\"EcxVvo\")(upright(\"vec\")), upright(\"EcxVvo\")(upright(\"intern_container\")::>(upright(\"vec_set\")::< upright(\"EcxVecOperand\"), >(*upright(\"vec\"), i, upright(\"to.erase\")()))))", + "colored_source": "upright(\"EcxcanSubstVecVecOperandBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]), upright(\"EcxVvo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"vec_set\")::< upright(\"EcxVecOperand\"), >(*upright(\"vec\"), i, upright(\"to.erase\")())) $]))" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_2", + "entry": { + "target_id": "effect:effect_2", + "label": "rel1", + "plain_source": "upright(\"EcxcanSubstVecVecOperandBeneath\")(upright(\"above\"), upright(\"EcxVvo\")(upright(\"vec\")), upright(\"EcxVvo\")(upright(\"intern_container\")::>(upright(\"vec_set\")::< upright(\"EcxVecOperand\"), >(*upright(\"vec\"), i, upright(\"to.erase\")()))))", + "colored_source": "upright(\"EcxcanSubstVecVecOperandBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]), upright(\"EcxVvo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"vec_set\")::< upright(\"EcxVecOperand\"), >(*upright(\"vec\"), i, upright(\"to.erase\")())) $]))" + } + } + ], + "formula_source": { + "plain": "frac(i \\ upright(\"can_subst_VecOperand_beneath\")(upright(\"above\"), upright(\"from\"), upright(\"to\")) \\ upright(\"_t2\") \\ upright(\"VVO\")(upright(\"vec\")), upright(\"EcxcanSubstVecVecOperandBeneath\")(upright(\"above\"), upright(\"EcxVvo\")(upright(\"vec\")), upright(\"EcxVvo\")(upright(\"intern_container\")::>(upright(\"vec_set\")::< upright(\"EcxVecOperand\"), >(*upright(\"vec\"), i, upright(\"to.erase\")()))))) quad upright(\"if\") quad i == upright(\"_t2.a1\") \\ upright(\"from\") == upright(\"_t2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"can_subst_VecOperand_beneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"from\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"to\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], upright(\"EcxcanSubstVecVecOperandBeneath\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"above\") $], upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]), upright(\"EcxVvo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"vec_set\")::< upright(\"EcxVecOperand\"), >(*upright(\"vec\"), i, upright(\"to.erase\")())) $]))) quad upright(\"if\") quad i == upright(\"_t2.a1\") \\ upright(\"from\") == upright(\"_t2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6893_5_MyTxEggccExtraction_add_rule__r0072__9a994855c400944e", + "display_name": "r0072", + "rule_name": "r0072", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 208729, + "line": 6893, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 208729, + "end": 209058 + }, + "pattern_range": { + "start": 208775, + "end": 208786 + }, + "action_range": { + "start": 208788, + "end": 209057 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 69631, + "end": 69664 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 69669, + "end": 69702 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty: EcxType", + "range": { + "start": 69707, + "end": 69738 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 69743, + "end": 69790 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "x1: EcxOperand", + "range": { + "start": 69795, + "end": 69829 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxbadd", + "label": "_t2: Ecxbadd", + "range": { + "start": 69834, + "end": 69872 + }, + "inputs": [ + "ty", + "a", + "b" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstExpr", + "label": "_t1: EcxSubstExpr", + "range": { + "start": 69877, + "end": 69918 + }, + "inputs": [ + "_t2", + "x1" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "a", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "b", + "kind": "operand", + "index": 2 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x1", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "a", + "b", + "ty", + "x0", + "x1", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 70018, + "end": 70020 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@208818:208882", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_operand(pat.a, ctx.devalue(pat.x0), pat.x1)", + "semantic_text": null, + "referenced_pat_vars": [ + "a", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 208818, + "end": 208882 + } + }, + { + "id": "effect_1", + "effect_id": "effect@208901:208965", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_subst_operand(pat.b, ctx.devalue(pat.x0), pat.x1)", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 208901, + "end": 208965 + } + }, + { + "id": "effect_2", + "effect_id": "effect@208984:209018", + "bound_var": "t1", + "source_text": "ctx.insert_ecxbadd(pat.ty, t2, t3)", + "semantic_text": null, + "referenced_pat_vars": [ + "ty" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 208984, + "end": 209018 + } + }, + { + "id": "effect_3", + "effect_id": "effect@209028:209050", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 209028, + "end": 209050 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0072", + "premises": [ + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxbadd", + "plain_source": "upright(\"badd\")(upright(\"ty\"), a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"SubstOperand\")(a, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"SubstOperand\")(b, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"badd\")(upright(\"ty\"), (upright(\"SubstOperand\")(a, x_0, x_1)), (upright(\"SubstOperand\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_3", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"badd\")(upright(\"ty\"), (upright(\"SubstOperand\")(a, x_0, x_1)), (upright(\"SubstOperand\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(x_0 \\ upright(\"_t1\") \\ upright(\"badd\")(upright(\"ty\"), a, b), upright(\"_t1\") arrow.r.double upright(\"badd\")(upright(\"ty\"), (upright(\"SubstOperand\")(a, x_0, x_1)), (upright(\"SubstOperand\")(b, x_0, x_1)))) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6899_5_MyTxEggccExtraction_add_rule__r0073__391474199a18439b", + "display_name": "r0073", + "rule_name": "r0073", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 209064, + "line": 6899, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 209064, + "end": 209393 + }, + "pattern_range": { + "start": 209110, + "end": 209121 + }, + "action_range": { + "start": 209123, + "end": 209392 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 70264, + "end": 70297 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 70302, + "end": 70335 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty: EcxType", + "range": { + "start": 70340, + "end": 70371 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 70376, + "end": 70423 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "x1: EcxOperand", + "range": { + "start": 70428, + "end": 70462 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxbsub", + "label": "_t2: Ecxbsub", + "range": { + "start": 70467, + "end": 70505 + }, + "inputs": [ + "ty", + "a", + "b" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstExpr", + "label": "_t1: EcxSubstExpr", + "range": { + "start": 70510, + "end": 70551 + }, + "inputs": [ + "_t2", + "x1" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "a", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "b", + "kind": "operand", + "index": 2 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x1", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "a", + "b", + "ty", + "x0", + "x1", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 70651, + "end": 70653 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@209153:209217", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_operand(pat.a, ctx.devalue(pat.x0), pat.x1)", + "semantic_text": null, + "referenced_pat_vars": [ + "a", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 209153, + "end": 209217 + } + }, + { + "id": "effect_1", + "effect_id": "effect@209236:209300", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_subst_operand(pat.b, ctx.devalue(pat.x0), pat.x1)", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 209236, + "end": 209300 + } + }, + { + "id": "effect_2", + "effect_id": "effect@209319:209353", + "bound_var": "t1", + "source_text": "ctx.insert_ecxbsub(pat.ty, t2, t3)", + "semantic_text": null, + "referenced_pat_vars": [ + "ty" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 209319, + "end": 209353 + } + }, + { + "id": "effect_3", + "effect_id": "effect@209363:209385", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 209363, + "end": 209385 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0073", + "premises": [ + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxbsub", + "plain_source": "upright(\"bsub\")(upright(\"ty\"), a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"SubstOperand\")(a, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"SubstOperand\")(b, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"bsub\")(upright(\"ty\"), (upright(\"SubstOperand\")(a, x_0, x_1)), (upright(\"SubstOperand\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_3", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"bsub\")(upright(\"ty\"), (upright(\"SubstOperand\")(a, x_0, x_1)), (upright(\"SubstOperand\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(x_0 \\ upright(\"_t1\") \\ upright(\"bsub\")(upright(\"ty\"), a, b), upright(\"_t1\") arrow.r.double upright(\"bsub\")(upright(\"ty\"), (upright(\"SubstOperand\")(a, x_0, x_1)), (upright(\"SubstOperand\")(b, x_0, x_1)))) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6905_5_MyTxEggccExtraction_add_rule__r0074__b8660a97ee324c28", + "display_name": "r0074", + "rule_name": "r0074", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 209399, + "line": 6905, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 209399, + "end": 209728 + }, + "pattern_range": { + "start": 209445, + "end": 209456 + }, + "action_range": { + "start": 209458, + "end": 209727 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 70897, + "end": 70930 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 70935, + "end": 70968 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty: EcxType", + "range": { + "start": 70973, + "end": 71004 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 71009, + "end": 71056 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "x1: EcxOperand", + "range": { + "start": 71061, + "end": 71095 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxbmul", + "label": "_t2: Ecxbmul", + "range": { + "start": 71100, + "end": 71138 + }, + "inputs": [ + "ty", + "a", + "b" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstExpr", + "label": "_t1: EcxSubstExpr", + "range": { + "start": 71143, + "end": 71184 + }, + "inputs": [ + "_t2", + "x1" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "a", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "b", + "kind": "operand", + "index": 2 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x1", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "a", + "b", + "ty", + "x0", + "x1", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 71284, + "end": 71286 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@209488:209552", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_operand(pat.a, ctx.devalue(pat.x0), pat.x1)", + "semantic_text": null, + "referenced_pat_vars": [ + "a", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 209488, + "end": 209552 + } + }, + { + "id": "effect_1", + "effect_id": "effect@209571:209635", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_subst_operand(pat.b, ctx.devalue(pat.x0), pat.x1)", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 209571, + "end": 209635 + } + }, + { + "id": "effect_2", + "effect_id": "effect@209654:209688", + "bound_var": "t1", + "source_text": "ctx.insert_ecxbmul(pat.ty, t2, t3)", + "semantic_text": null, + "referenced_pat_vars": [ + "ty" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 209654, + "end": 209688 + } + }, + { + "id": "effect_3", + "effect_id": "effect@209698:209720", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 209698, + "end": 209720 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0074", + "premises": [ + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxbmul", + "plain_source": "upright(\"bmul\")(upright(\"ty\"), a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"SubstOperand\")(a, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"SubstOperand\")(b, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"bmul\")(upright(\"ty\"), (upright(\"SubstOperand\")(a, x_0, x_1)), (upright(\"SubstOperand\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_3", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"bmul\")(upright(\"ty\"), (upright(\"SubstOperand\")(a, x_0, x_1)), (upright(\"SubstOperand\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(x_0 \\ upright(\"_t1\") \\ upright(\"bmul\")(upright(\"ty\"), a, b), upright(\"_t1\") arrow.r.double upright(\"bmul\")(upright(\"ty\"), (upright(\"SubstOperand\")(a, x_0, x_1)), (upright(\"SubstOperand\")(b, x_0, x_1)))) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6911_5_MyTxEggccExtraction_add_rule__r0075__326865d2d786f35e", + "display_name": "r0075", + "rule_name": "r0075", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 209734, + "line": 6911, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 209734, + "end": 210063 + }, + "pattern_range": { + "start": 209780, + "end": 209791 + }, + "action_range": { + "start": 209793, + "end": 210062 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 71530, + "end": 71563 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 71568, + "end": 71601 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty: EcxType", + "range": { + "start": 71606, + "end": 71637 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 71642, + "end": 71689 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "x1: EcxOperand", + "range": { + "start": 71694, + "end": 71728 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxbdiv", + "label": "_t2: Ecxbdiv", + "range": { + "start": 71733, + "end": 71771 + }, + "inputs": [ + "ty", + "a", + "b" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstExpr", + "label": "_t1: EcxSubstExpr", + "range": { + "start": 71776, + "end": 71817 + }, + "inputs": [ + "_t2", + "x1" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "a", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "b", + "kind": "operand", + "index": 2 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x1", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "a", + "b", + "ty", + "x0", + "x1", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 71917, + "end": 71919 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@209823:209887", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_operand(pat.a, ctx.devalue(pat.x0), pat.x1)", + "semantic_text": null, + "referenced_pat_vars": [ + "a", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 209823, + "end": 209887 + } + }, + { + "id": "effect_1", + "effect_id": "effect@209906:209970", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_subst_operand(pat.b, ctx.devalue(pat.x0), pat.x1)", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 209906, + "end": 209970 + } + }, + { + "id": "effect_2", + "effect_id": "effect@209989:210023", + "bound_var": "t1", + "source_text": "ctx.insert_ecxbdiv(pat.ty, t2, t3)", + "semantic_text": null, + "referenced_pat_vars": [ + "ty" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 209989, + "end": 210023 + } + }, + { + "id": "effect_3", + "effect_id": "effect@210033:210055", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 210033, + "end": 210055 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0075", + "premises": [ + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxbdiv", + "plain_source": "upright(\"bdiv\")(upright(\"ty\"), a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"SubstOperand\")(a, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"SubstOperand\")(b, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"bdiv\")(upright(\"ty\"), (upright(\"SubstOperand\")(a, x_0, x_1)), (upright(\"SubstOperand\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_3", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"bdiv\")(upright(\"ty\"), (upright(\"SubstOperand\")(a, x_0, x_1)), (upright(\"SubstOperand\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(x_0 \\ upright(\"_t1\") \\ upright(\"bdiv\")(upright(\"ty\"), a, b), upright(\"_t1\") arrow.r.double upright(\"bdiv\")(upright(\"ty\"), (upright(\"SubstOperand\")(a, x_0, x_1)), (upright(\"SubstOperand\")(b, x_0, x_1)))) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6917_5_MyTxEggccExtraction_add_rule__r0076__1b23e6bc9b15fd6d", + "display_name": "r0076", + "rule_name": "r0076", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 210069, + "line": 6917, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 210069, + "end": 210397 + }, + "pattern_range": { + "start": 210115, + "end": 210126 + }, + "action_range": { + "start": 210128, + "end": 210396 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 72162, + "end": 72195 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 72200, + "end": 72233 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty: EcxType", + "range": { + "start": 72238, + "end": 72269 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 72274, + "end": 72321 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "x1: EcxOperand", + "range": { + "start": 72326, + "end": 72360 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxblt", + "label": "_t2: Ecxblt", + "range": { + "start": 72365, + "end": 72402 + }, + "inputs": [ + "ty", + "a", + "b" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstExpr", + "label": "_t1: EcxSubstExpr", + "range": { + "start": 72407, + "end": 72448 + }, + "inputs": [ + "_t2", + "x1" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "a", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "b", + "kind": "operand", + "index": 2 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x1", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "a", + "b", + "ty", + "x0", + "x1", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 72548, + "end": 72550 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@210158:210222", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_operand(pat.a, ctx.devalue(pat.x0), pat.x1)", + "semantic_text": null, + "referenced_pat_vars": [ + "a", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 210158, + "end": 210222 + } + }, + { + "id": "effect_1", + "effect_id": "effect@210241:210305", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_subst_operand(pat.b, ctx.devalue(pat.x0), pat.x1)", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 210241, + "end": 210305 + } + }, + { + "id": "effect_2", + "effect_id": "effect@210324:210357", + "bound_var": "t1", + "source_text": "ctx.insert_ecxblt(pat.ty, t2, t3)", + "semantic_text": null, + "referenced_pat_vars": [ + "ty" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 210324, + "end": 210357 + } + }, + { + "id": "effect_3", + "effect_id": "effect@210367:210389", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 210367, + "end": 210389 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0076", + "premises": [ + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxblt", + "plain_source": "upright(\"blt\")(upright(\"ty\"), a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"SubstOperand\")(a, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"SubstOperand\")(b, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"blt\")(upright(\"ty\"), (upright(\"SubstOperand\")(a, x_0, x_1)), (upright(\"SubstOperand\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_3", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"blt\")(upright(\"ty\"), (upright(\"SubstOperand\")(a, x_0, x_1)), (upright(\"SubstOperand\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(x_0 \\ upright(\"_t1\") \\ upright(\"blt\")(upright(\"ty\"), a, b), upright(\"_t1\") arrow.r.double upright(\"blt\")(upright(\"ty\"), (upright(\"SubstOperand\")(a, x_0, x_1)), (upright(\"SubstOperand\")(b, x_0, x_1)))) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6923_5_MyTxEggccExtraction_add_rule__r0077__f9e4eba5475c0f75", + "display_name": "r0077", + "rule_name": "r0077", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 210403, + "line": 6923, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 210403, + "end": 210578 + }, + "pattern_range": { + "start": 210449, + "end": 210460 + }, + "action_range": { + "start": 210462, + "end": 210577 + } + }, + "nodes": [ + { + "id": "lit", + "kind": "query_leaf", + "dsl_type": "EcxLiteral", + "label": "lit: EcxLiteral", + "range": { + "start": 72800, + "end": 72835 + }, + "inputs": [] + }, + { + "id": "ops", + "kind": "query_leaf", + "dsl_type": "EcxConstOps", + "label": "ops: EcxConstOps", + "range": { + "start": 72840, + "end": 72876 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty: EcxType", + "range": { + "start": 72881, + "end": 72912 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 72917, + "end": 72964 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "x1: EcxOperand", + "range": { + "start": 72969, + "end": 73003 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxConst", + "label": "_t2: EcxConst", + "range": { + "start": 73008, + "end": 73051 + }, + "inputs": [ + "ty", + "ops", + "lit" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstExpr", + "label": "_t1: EcxSubstExpr", + "range": { + "start": 73056, + "end": 73097 + }, + "inputs": [ + "_t2", + "x1" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "ops", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "lit", + "kind": "operand", + "index": 2 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x1", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "lit", + "ops", + "ty", + "x0", + "x1", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 73201, + "end": 73203 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@210492:210538", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_const(pat.ty, pat.ops, pat.lit)", + "semantic_text": null, + "referenced_pat_vars": [ + "lit", + "ops", + "ty" + ], + "referenced_action_vars": [], + "range": { + "start": 210492, + "end": 210538 + } + }, + { + "id": "effect_1", + "effect_id": "effect@210548:210570", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 210548, + "end": 210570 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0077", + "premises": [ + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxConst", + "plain_source": "upright(\"Const\")(upright(\"ty\"), upright(\"ops\"), upright(\"lit\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lit\") $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"Const\")(upright(\"ty\"), upright(\"ops\"), upright(\"lit\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lit\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"Const\")(upright(\"ty\"), upright(\"ops\"), upright(\"lit\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lit\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(x_0 \\ upright(\"_t1\") \\ upright(\"Const\")(upright(\"ty\"), upright(\"ops\"), upright(\"lit\")), upright(\"_t1\") arrow.r.double upright(\"Const\")(upright(\"ty\"), upright(\"ops\"), upright(\"lit\"))) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lit\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lit\") $]) $]) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6927_5_MyTxEggccExtraction_add_rule__r0078__6b21f1f23ada2974", + "display_name": "r0078", + "rule_name": "r0078", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 210584, + "line": 6927, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 210584, + "end": 210879 + }, + "pattern_range": { + "start": 210630, + "end": 210641 + }, + "action_range": { + "start": 210643, + "end": 210878 + } + }, + "nodes": [ + { + "id": "args", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "args: EcxVecOperand", + "range": { + "start": 73472, + "end": 73511 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query", + "dsl_type": "", + "label": "f: ", + "range": { + "start": 73516, + "end": 73564 + }, + "inputs": [] + }, + { + "id": "n_outs", + "kind": "query", + "dsl_type": "", + "label": "n_outs: ", + "range": { + "start": 73569, + "end": 73624 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxOptionType", + "label": "ty: EcxOptionType", + "range": { + "start": 73629, + "end": 73666 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 73671, + "end": 73718 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "x1: EcxOperand", + "range": { + "start": 73723, + "end": 73757 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxCall", + "label": "_t2: EcxCall", + "range": { + "start": 73762, + "end": 73799 + }, + "inputs": [ + "ty", + "args" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstExpr", + "label": "_t1: EcxSubstExpr", + "range": { + "start": 73804, + "end": 73845 + }, + "inputs": [ + "_t2", + "x1" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "args", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x1", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "args", + "f", + "n_outs", + "ty", + "x0", + "x1", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "f.handle().eq(&_t2.handle_a1())", + "semantic_text": "f == _t2.a1", + "referenced_vars": [ + "_t2", + "f" + ], + "range": { + "start": 74062, + "end": 74064 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "n_outs.handle().eq(&_t2.handle_a3())", + "semantic_text": "n_outs == _t2.a3", + "referenced_vars": [ + "_t2", + "n_outs" + ], + "range": { + "start": 74082, + "end": 74084 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 74102, + "end": 74104 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@210673:210744", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_vec_operand(pat.args, ctx.devalue(pat.x0), pat.x1)", + "semantic_text": null, + "referenced_pat_vars": [ + "args", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 210673, + "end": 210744 + } + }, + { + "id": "effect_1", + "effect_id": "effect@210763:210839", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_call(pat.ty, ctx.devalue(pat.f), t2, ctx.devalue(pat.n_outs))", + "semantic_text": null, + "referenced_pat_vars": [ + "f", + "n_outs", + "ty" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 210763, + "end": 210839 + } + }, + { + "id": "effect_2", + "effect_id": "effect@210849:210871", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 210849, + "end": 210871 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0078", + "premises": [ + { + "target_id": "f", + "label": "f: ", + "plain_source": "f", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ f $]" + }, + { + "target_id": "n_outs", + "label": "n_outs: ", + "plain_source": "upright(\"n_outs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"n_outs\") $]" + }, + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstExpr", + "plain_source": "upright(\"EcxSubstExpr\")(upright(\"_t2\"), x_1)", + "colored_source": "upright(\"EcxSubstExpr\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $])" + }, + { + "target_id": "_t2", + "label": "_t2: EcxCall", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + } + ], + "side_conditions": [ + "f == upright(\"_t2.a1\")", + "upright(\"n_outs\") == upright(\"_t2.a3\")", + "x_0 == upright(\"_t1.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"SubstVecOperand\")(upright(\"args\"), x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"args\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"Call\")(upright(\"ty\"), f, (upright(\"SubstVecOperand\")(upright(\"args\"), x_0, x_1)), upright(\"n_outs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Call\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ f $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"args\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"n_outs\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstExpr", + "plain_source": "upright(\"EcxSubstExpr\")(upright(\"_t2\"), x_1)", + "colored_source": "upright(\"EcxSubstExpr\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $])" + }, + "to": { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"Call\")(upright(\"ty\"), f, (upright(\"SubstVecOperand\")(upright(\"args\"), x_0, x_1)), upright(\"n_outs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Call\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ f $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"args\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"n_outs\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(f \\ upright(\"n_outs\") \\ x_0 \\ upright(\"EcxSubstExpr\")(upright(\"_t2\"), x_1) \\ upright(\"_t2\"), upright(\"EcxSubstExpr\")(upright(\"_t2\"), x_1) arrow.r.double upright(\"Call\")(upright(\"ty\"), f, (upright(\"SubstVecOperand\")(upright(\"args\"), x_0, x_1)), upright(\"n_outs\"))) quad upright(\"if\") quad f == upright(\"_t2.a1\") \\ upright(\"n_outs\") == upright(\"_t2.a3\") \\ x_0 == upright(\"_t1.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ f $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"n_outs\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ upright(\"EcxSubstExpr\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], upright(\"EcxSubstExpr\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Call\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ f $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"args\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"n_outs\") $]) $]) quad upright(\"if\") quad f == upright(\"_t2.a1\") \\ upright(\"n_outs\") == upright(\"_t2.a3\") \\ x_0 == upright(\"_t1.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6932_5_MyTxEggccExtraction_add_rule__r0079__e8c1de4bc7e4a0c9", + "display_name": "r0079", + "rule_name": "r0079", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 210885, + "line": 6932, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 210885, + "end": 211208 + }, + "pattern_range": { + "start": 210931, + "end": 210942 + }, + "action_range": { + "start": 210944, + "end": 211207 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 74332, + "end": 74365 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 74370, + "end": 74403 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 74408, + "end": 74455 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "x1: EcxOperand", + "range": { + "start": 74460, + "end": 74494 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxPRINT", + "label": "_t2: EcxPRINT", + "range": { + "start": 74499, + "end": 74533 + }, + "inputs": [ + "a", + "b" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstExpr", + "label": "_t1: EcxSubstExpr", + "range": { + "start": 74538, + "end": 74579 + }, + "inputs": [ + "_t2", + "x1" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "a", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "b", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x1", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "a", + "b", + "x0", + "x1", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 74675, + "end": 74677 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@210974:211038", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_operand(pat.a, ctx.devalue(pat.x0), pat.x1)", + "semantic_text": null, + "referenced_pat_vars": [ + "a", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 210974, + "end": 211038 + } + }, + { + "id": "effect_1", + "effect_id": "effect@211057:211121", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_subst_operand(pat.b, ctx.devalue(pat.x0), pat.x1)", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 211057, + "end": 211121 + } + }, + { + "id": "effect_2", + "effect_id": "effect@211140:211168", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_print(t2, t3)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 211140, + "end": 211168 + } + }, + { + "id": "effect_3", + "effect_id": "effect@211178:211200", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 211178, + "end": 211200 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0079", + "premises": [ + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxPRINT", + "plain_source": "upright(\"PRINT\")(a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PRINT\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"SubstOperand\")(a, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"SubstOperand\")(b, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"EcxPrint\")(upright(\"SubstOperand\")(a, x_0, x_1), upright(\"SubstOperand\")(b, x_0, x_1))", + "colored_source": "upright(\"EcxPrint\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_3", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"EcxPrint\")(upright(\"SubstOperand\")(a, x_0, x_1), upright(\"SubstOperand\")(b, x_0, x_1))", + "colored_source": "upright(\"EcxPrint\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])" + } + } + ], + "formula_source": { + "plain": "frac(x_0 \\ upright(\"_t1\") \\ upright(\"PRINT\")(a, b), upright(\"_t1\") arrow.r.double upright(\"EcxPrint\")(upright(\"SubstOperand\")(a, x_0, x_1), upright(\"SubstOperand\")(b, x_0, x_1))) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PRINT\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double upright(\"EcxPrint\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6938_5_MyTxEggccExtraction_add_rule__r0080__0bd980b3579d283f", + "display_name": "r0080", + "rule_name": "r0080", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 211214, + "line": 6938, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 211214, + "end": 211327 + }, + "pattern_range": { + "start": 211260, + "end": 211271 + }, + "action_range": { + "start": 211273, + "end": 211326 + } + }, + "nodes": [ + { + "id": "v", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "v: EcxOperand", + "range": { + "start": 74866, + "end": 74899 + }, + "inputs": [] + }, + { + "id": "x", + "kind": "query", + "dsl_type": "", + "label": "x: ", + "range": { + "start": 74904, + "end": 74949 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxArg", + "label": "_t2: EcxArg", + "range": { + "start": 74954, + "end": 74980 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstOperand", + "label": "_t1: EcxSubstOperand", + "range": { + "start": 74985, + "end": 75028 + }, + "inputs": [ + "_t2", + "v" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "v", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "v", + "x", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x.handle().eq(&_t2.handle_a0())", + "semantic_text": "x == _t2.a0", + "referenced_vars": [ + "_t2", + "x" + ], + "range": { + "start": 75161, + "end": 75163 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "x.handle().eq(&_t1.handle_a1())", + "semantic_text": "x == _t1.a1", + "referenced_vars": [ + "_t1", + "x" + ], + "range": { + "start": 75172, + "end": 75174 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@211294:211319", + "bound_var": null, + "source_text": "ctx.union(pat._t1, pat.v)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1", + "v" + ], + "referenced_action_vars": [], + "range": { + "start": 211294, + "end": 211319 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0080", + "premises": [ + { + "target_id": "x", + "label": "x: ", + "plain_source": "x", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstOperand", + "plain_source": "upright(\"EcxSubstOperand\")(upright(\"_t2\"), v)", + "colored_source": "upright(\"EcxSubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ v $])" + }, + { + "target_id": "_t2", + "label": "_t2: EcxArg", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + } + ], + "side_conditions": [ + "x == upright(\"_t2.a0\")", + "x == upright(\"_t1.a1\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_0", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstOperand", + "plain_source": "upright(\"EcxSubstOperand\")(upright(\"_t2\"), v)", + "colored_source": "upright(\"EcxSubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ v $])" + }, + "to": { + "target_id": "v", + "label": "v: EcxOperand", + "plain_source": "v", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ v $]" + } + } + ], + "formula_source": { + "plain": "frac(x \\ upright(\"EcxSubstOperand\")(upright(\"_t2\"), v) \\ upright(\"_t2\"), upright(\"EcxSubstOperand\")(upright(\"_t2\"), v) arrow.r.double v) quad upright(\"if\") quad x == upright(\"_t2.a0\") \\ x == upright(\"_t1.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x $] \\ upright(\"EcxSubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ v $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], upright(\"EcxSubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ v $]) arrow.r.double #text(fill: rgb(\"#5F7A8A\"))[$ v $]) quad upright(\"if\") quad x == upright(\"_t2.a0\") \\ x == upright(\"_t1.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6941_5_MyTxEggccExtraction_add_rule__r0081__59ae6ff322b64478", + "display_name": "r0081", + "rule_name": "r0081", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 211333, + "line": 6941, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 211333, + "end": 211498 + }, + "pattern_range": { + "start": 211379, + "end": 211390 + }, + "action_range": { + "start": 211392, + "end": 211497 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "f: EcxOperand", + "range": { + "start": 75394, + "end": 75427 + }, + "inputs": [] + }, + { + "id": "v", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "v: EcxOperand", + "range": { + "start": 75432, + "end": 75465 + }, + "inputs": [] + }, + { + "id": "x", + "kind": "query", + "dsl_type": "", + "label": "x: ", + "range": { + "start": 75470, + "end": 75515 + }, + "inputs": [] + }, + { + "id": "y", + "kind": "query", + "dsl_type": "", + "label": "y: ", + "range": { + "start": 75520, + "end": 75565 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxArg", + "label": "_t2: EcxArg", + "range": { + "start": 75570, + "end": 75596 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstOperand", + "label": "_t1: EcxSubstOperand", + "range": { + "start": 75601, + "end": 75644 + }, + "inputs": [ + "_t2", + "v" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "v", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "f", + "v", + "x", + "y", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "y.handle().eq(&_t2.handle_a0())", + "semantic_text": "y == _t2.a0", + "referenced_vars": [ + "_t2", + "y" + ], + "range": { + "start": 75876, + "end": 75878 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "x.handle().eq(&_t1.handle_a1())", + "semantic_text": "x == _t1.a1", + "referenced_vars": [ + "_t1", + "x" + ], + "range": { + "start": 75896, + "end": 75898 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 75916, + "end": 75918 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "y.handle().ne(&x.handle())", + "semantic_text": "y != x", + "referenced_vars": [ + "x", + "y" + ], + "range": { + "start": 75936, + "end": 75938 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@211422:211460", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_arg(ctx.devalue(pat.y))", + "semantic_text": null, + "referenced_pat_vars": [ + "y" + ], + "referenced_action_vars": [], + "range": { + "start": 211422, + "end": 211460 + } + }, + { + "id": "effect_1", + "effect_id": "effect@211470:211490", + "bound_var": null, + "source_text": "ctx.union(pat.f, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "f" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 211470, + "end": 211490 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0081", + "premises": [ + { + "target_id": "x", + "label": "x: ", + "plain_source": "x", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x $]" + }, + { + "target_id": "y", + "label": "y: ", + "plain_source": "y", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ y $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstOperand", + "plain_source": "upright(\"EcxSubstOperand\")(upright(\"_t2\"), v)", + "colored_source": "upright(\"EcxSubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ v $])" + }, + { + "target_id": "_t2", + "label": "_t2: EcxArg", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + } + ], + "side_conditions": [ + "y == upright(\"_t2.a0\")", + "x == upright(\"_t1.a1\")", + "f == upright(\"_t1\")", + "y != x" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"Arg\")(y)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Arg\")(#text(fill: rgb(\"#5F7A8A\"))[$ y $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "f", + "label": "f: EcxOperand", + "plain_source": "f", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ f $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"Arg\")(y)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Arg\")(#text(fill: rgb(\"#5F7A8A\"))[$ y $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(x \\ y \\ upright(\"EcxSubstOperand\")(upright(\"_t2\"), v) \\ upright(\"_t2\"), f arrow.r.double upright(\"Arg\")(y)) quad upright(\"if\") quad y == upright(\"_t2.a0\") \\ x == upright(\"_t1.a1\") \\ f == upright(\"_t1\") \\ y != x", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ y $] \\ upright(\"EcxSubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ v $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ f $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Arg\")(#text(fill: rgb(\"#5F7A8A\"))[$ y $]) $]) quad upright(\"if\") quad y == upright(\"_t2.a0\") \\ x == upright(\"_t1.a1\") \\ f == upright(\"_t1\") \\ y != x" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6945_5_MyTxEggccExtraction_add_rule__r0082__978a48816ca8699d", + "display_name": "r0082", + "rule_name": "r0082", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 211504, + "line": 6945, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 211504, + "end": 211736 + }, + "pattern_range": { + "start": 211550, + "end": 211561 + }, + "action_range": { + "start": 211563, + "end": 211735 + } + }, + "nodes": [ + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "b: EcxBody", + "range": { + "start": 76146, + "end": 76176 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 76181, + "end": 76228 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "x1: EcxOperand", + "range": { + "start": 76233, + "end": 76267 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t2: EcxNode", + "range": { + "start": 76272, + "end": 76301 + }, + "inputs": [ + "b" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstOperand", + "label": "_t1: EcxSubstOperand", + "range": { + "start": 76306, + "end": 76350 + }, + "inputs": [ + "_t2", + "x1" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "b", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x1", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "b", + "x0", + "x1", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 76443, + "end": 76445 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@211593:211654", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_body(pat.b, ctx.devalue(pat.x0), pat.x1)", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 211593, + "end": 211654 + } + }, + { + "id": "effect_1", + "effect_id": "effect@211673:211696", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_node(t2)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 211673, + "end": 211696 + } + }, + { + "id": "effect_2", + "effect_id": "effect@211706:211728", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 211706, + "end": 211728 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0082", + "premises": [ + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstOperand", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxNode", + "plain_source": "upright(\"Node\")(b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"SubstBody\")(b, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"Node\")((upright(\"SubstBody\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Node\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstOperand", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"Node\")((upright(\"SubstBody\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Node\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(x_0 \\ upright(\"_t1\") \\ upright(\"Node\")(b), upright(\"_t1\") arrow.r.double upright(\"Node\")((upright(\"SubstBody\")(b, x_0, x_1)))) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Node\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6950_5_MyTxEggccExtraction_add_rule__r0083__e39127ee8288f218", + "display_name": "r0083", + "rule_name": "r0083", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 211742, + "line": 6950, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 211742, + "end": 211997 + }, + "pattern_range": { + "start": 211788, + "end": 211799 + }, + "action_range": { + "start": 211801, + "end": 211996 + } + }, + "nodes": [ + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "b: EcxBody", + "range": { + "start": 76668, + "end": 76698 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 76703, + "end": 76748 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 76753, + "end": 76800 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "x1: EcxOperand", + "range": { + "start": 76805, + "end": 76839 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxProject", + "label": "_t2: EcxProject", + "range": { + "start": 76844, + "end": 76876 + }, + "inputs": [ + "b" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstOperand", + "label": "_t1: EcxSubstOperand", + "range": { + "start": 76881, + "end": 76925 + }, + "inputs": [ + "_t2", + "x1" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "b", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x1", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "b", + "i", + "x0", + "x1", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_t2.handle_a0())", + "semantic_text": "i == _t2.a0", + "referenced_vars": [ + "_t2", + "i" + ], + "range": { + "start": 77067, + "end": 77069 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 77078, + "end": 77080 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@211831:211892", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_body(pat.b, ctx.devalue(pat.x0), pat.x1)", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 211831, + "end": 211892 + } + }, + { + "id": "effect_1", + "effect_id": "effect@211911:211957", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_project(ctx.devalue(pat.i), t2)", + "semantic_text": null, + "referenced_pat_vars": [ + "i" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 211911, + "end": 211957 + } + }, + { + "id": "effect_2", + "effect_id": "effect@211967:211989", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 211967, + "end": 211989 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0083", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstOperand", + "plain_source": "upright(\"EcxSubstOperand\")(upright(\"_t2\"), x_1)", + "colored_source": "upright(\"EcxSubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $])" + }, + { + "target_id": "_t2", + "label": "_t2: EcxProject", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + } + ], + "side_conditions": [ + "i == upright(\"_t2.a0\")", + "x_0 == upright(\"_t1.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"SubstBody\")(b, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"Project\")(i, (upright(\"SubstBody\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Project\")(#text(fill: rgb(\"#5F7A8A\"))[$ i $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstOperand", + "plain_source": "upright(\"EcxSubstOperand\")(upright(\"_t2\"), x_1)", + "colored_source": "upright(\"EcxSubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $])" + }, + "to": { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"Project\")(i, (upright(\"SubstBody\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Project\")(#text(fill: rgb(\"#5F7A8A\"))[$ i $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(i \\ x_0 \\ upright(\"EcxSubstOperand\")(upright(\"_t2\"), x_1) \\ upright(\"_t2\"), upright(\"EcxSubstOperand\")(upright(\"_t2\"), x_1) arrow.r.double upright(\"Project\")(i, (upright(\"SubstBody\")(b, x_0, x_1)))) quad upright(\"if\") quad i == upright(\"_t2.a0\") \\ x_0 == upright(\"_t1.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ upright(\"EcxSubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], upright(\"EcxSubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Project\")(#text(fill: rgb(\"#5F7A8A\"))[$ i $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]) quad upright(\"if\") quad i == upright(\"_t2.a0\") \\ x_0 == upright(\"_t1.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6955_5_MyTxEggccExtraction_add_rule__r0084__bedea25db830c7ae", + "display_name": "r0084", + "rule_name": "r0084", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 212003, + "line": 6955, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 212003, + "end": 212238 + }, + "pattern_range": { + "start": 212049, + "end": 212060 + }, + "action_range": { + "start": 212062, + "end": 212237 + } + }, + "nodes": [ + { + "id": "e", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "e: EcxExpr", + "range": { + "start": 77287, + "end": 77317 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 77322, + "end": 77369 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "x1: EcxOperand", + "range": { + "start": 77374, + "end": 77408 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t2: EcxPureOp", + "range": { + "start": 77413, + "end": 77444 + }, + "inputs": [ + "e" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstBody", + "label": "_t1: EcxSubstBody", + "range": { + "start": 77449, + "end": 77490 + }, + "inputs": [ + "_t2", + "x1" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "e", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x1", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "e", + "x0", + "x1", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 77583, + "end": 77585 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@212092:212153", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_expr(pat.e, ctx.devalue(pat.x0), pat.x1)", + "semantic_text": null, + "referenced_pat_vars": [ + "e", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 212092, + "end": 212153 + } + }, + { + "id": "effect_1", + "effect_id": "effect@212172:212198", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_pure_op(t2)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 212172, + "end": 212198 + } + }, + { + "id": "effect_2", + "effect_id": "effect@212208:212230", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 212208, + "end": 212230 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0084", + "premises": [ + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstBody", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxPureOp", + "plain_source": "upright(\"PureOp\")(e)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"SubstExpr\")(e, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstExpr\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"PureOp\")((upright(\"SubstExpr\")(e, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstExpr\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstBody", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"PureOp\")((upright(\"SubstExpr\")(e, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstExpr\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(x_0 \\ upright(\"_t1\") \\ upright(\"PureOp\")(e), upright(\"_t1\") arrow.r.double upright(\"PureOp\")((upright(\"SubstExpr\")(e, x_0, x_1)))) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstExpr\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6960_5_MyTxEggccExtraction_add_rule__r0085__3e1400f934926111", + "display_name": "r0085", + "rule_name": "r0085", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 212244, + "line": 6960, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 212244, + "end": 212592 + }, + "pattern_range": { + "start": 212290, + "end": 212301 + }, + "action_range": { + "start": 212303, + "end": 212591 + } + }, + "nodes": [ + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 77855, + "end": 77896 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "outputs: EcxVecVecOperand", + "range": { + "start": 77901, + "end": 77946 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 77951, + "end": 77987 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 77992, + "end": 78039 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "x1: EcxOperand", + "range": { + "start": 78044, + "end": 78078 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxGamma", + "label": "_t2: EcxGamma", + "range": { + "start": 78083, + "end": 78135 + }, + "inputs": [ + "pred", + "inputs", + "outputs" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstBody", + "label": "_t1: EcxSubstBody", + "range": { + "start": 78140, + "end": 78181 + }, + "inputs": [ + "_t2", + "x1" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "outputs", + "kind": "operand", + "index": 2 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x1", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "inputs", + "outputs", + "pred", + "x0", + "x1", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 78294, + "end": 78296 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@212333:212400", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_operand(pat.pred, ctx.devalue(pat.x0), pat.x1)", + "semantic_text": null, + "referenced_pat_vars": [ + "pred", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 212333, + "end": 212400 + } + }, + { + "id": "effect_1", + "effect_id": "effect@212419:212492", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_subst_vec_operand(pat.inputs, ctx.devalue(pat.x0), pat.x1)", + "semantic_text": null, + "referenced_pat_vars": [ + "inputs", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 212419, + "end": 212492 + } + }, + { + "id": "effect_2", + "effect_id": "effect@212511:212552", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_gamma(t2, t3, pat.outputs)", + "semantic_text": null, + "referenced_pat_vars": [ + "outputs" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 212511, + "end": 212552 + } + }, + { + "id": "effect_3", + "effect_id": "effect@212562:212584", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 212562, + "end": 212584 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0085", + "premises": [ + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstBody", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxGamma", + "plain_source": "upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"SubstOperand\")(upright(\"pred\"), x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"SubstVecOperand\")(upright(\"inputs\"), x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"Gamma\")((upright(\"SubstOperand\")(upright(\"pred\"), x_0, x_1)), (upright(\"SubstVecOperand\")(upright(\"inputs\"), x_0, x_1)), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_3", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstBody", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"Gamma\")((upright(\"SubstOperand\")(upright(\"pred\"), x_0, x_1)), (upright(\"SubstVecOperand\")(upright(\"inputs\"), x_0, x_1)), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(x_0 \\ upright(\"_t1\") \\ upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\")), upright(\"_t1\") arrow.r.double upright(\"Gamma\")((upright(\"SubstOperand\")(upright(\"pred\"), x_0, x_1)), (upright(\"SubstVecOperand\")(upright(\"inputs\"), x_0, x_1)), upright(\"outputs\"))) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6966_5_MyTxEggccExtraction_add_rule__r0086__26dcefe2f82cb066", + "display_name": "r0086", + "rule_name": "r0086", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 212598, + "line": 6966, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 212598, + "end": 212866 + }, + "pattern_range": { + "start": 212644, + "end": 212655 + }, + "action_range": { + "start": 212657, + "end": 212865 + } + }, + "nodes": [ + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 78563, + "end": 78604 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "outputs: EcxVecOperand", + "range": { + "start": 78609, + "end": 78651 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 78656, + "end": 78692 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 78697, + "end": 78744 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "x1: EcxOperand", + "range": { + "start": 78749, + "end": 78783 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxTheta", + "label": "_t2: EcxTheta", + "range": { + "start": 78788, + "end": 78840 + }, + "inputs": [ + "pred", + "inputs", + "outputs" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstBody", + "label": "_t1: EcxSubstBody", + "range": { + "start": 78845, + "end": 78886 + }, + "inputs": [ + "_t2", + "x1" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "outputs", + "kind": "operand", + "index": 2 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x1", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "inputs", + "outputs", + "pred", + "x0", + "x1", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 78999, + "end": 79001 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@212687:212760", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_vec_operand(pat.inputs, ctx.devalue(pat.x0), pat.x1)", + "semantic_text": null, + "referenced_pat_vars": [ + "inputs", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 212687, + "end": 212760 + } + }, + { + "id": "effect_1", + "effect_id": "effect@212779:212826", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_theta(pat.pred, t2, pat.outputs)", + "semantic_text": null, + "referenced_pat_vars": [ + "outputs", + "pred" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 212779, + "end": 212826 + } + }, + { + "id": "effect_2", + "effect_id": "effect@212836:212858", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 212836, + "end": 212858 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0086", + "premises": [ + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstBody", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxTheta", + "plain_source": "upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"SubstVecOperand\")(upright(\"inputs\"), x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"Theta\")(upright(\"pred\"), (upright(\"SubstVecOperand\")(upright(\"inputs\"), x_0, x_1)), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstBody", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"Theta\")(upright(\"pred\"), (upright(\"SubstVecOperand\")(upright(\"inputs\"), x_0, x_1)), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(x_0 \\ upright(\"_t1\") \\ upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\")), upright(\"_t1\") arrow.r.double upright(\"Theta\")(upright(\"pred\"), (upright(\"SubstVecOperand\")(upright(\"inputs\"), x_0, x_1)), upright(\"outputs\"))) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6971_5_MyTxEggccExtraction_add_rule__r0087__3649236b93d3fdf5", + "display_name": "r0087", + "rule_name": "r0087", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 212872, + "line": 6971, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 212872, + "end": 213097 + }, + "pattern_range": { + "start": 212918, + "end": 212929 + }, + "action_range": { + "start": 212931, + "end": 213096 + } + }, + "nodes": [ + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "vec: EcxVecOperand", + "range": { + "start": 79202, + "end": 79240 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 79245, + "end": 79292 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "x1: EcxOperand", + "range": { + "start": 79297, + "end": 79331 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstVecOperand", + "label": "_t1: EcxSubstVecOperand", + "range": { + "start": 79336, + "end": 79383 + }, + "inputs": [ + "vec", + "x1" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x1", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "vec", + "x0", + "x1", + "_t1" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 79473, + "end": 79475 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@212973:213057", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_subst_vec_operand_helper(pat.vec, ctx.devalue(pat.x0), pat.x1, 0_i64)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 212973, + "end": 213057 + } + }, + { + "id": "effect_1", + "effect_id": "effect@213067:213089", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 213067, + "end": 213089 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0087", + "premises": [ + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstVecOperand", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"EcxSubstVecOperandHelper\")(upright(\"vec\"), x_0, x_1, 0)", + "colored_source": "upright(\"EcxSubstVecOperandHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $], #text(fill: rgb(\"#B86A5B\"))[$ 0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstVecOperand", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"EcxSubstVecOperandHelper\")(upright(\"vec\"), x_0, x_1, 0)", + "colored_source": "upright(\"EcxSubstVecOperandHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $], #text(fill: rgb(\"#B86A5B\"))[$ 0 $])" + } + } + ], + "formula_source": { + "plain": "frac(x_0 \\ upright(\"_t1\"), upright(\"_t1\") arrow.r.double upright(\"EcxSubstVecOperandHelper\")(upright(\"vec\"), x_0, x_1, 0)) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double upright(\"EcxSubstVecOperandHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $], #text(fill: rgb(\"#B86A5B\"))[$ 0 $])) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__6976_5_MyTxEggccExtraction_add_rule__r0088__350f40d32b7b4679", + "display_name": "r0088", + "rule_name": "r0088", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 213103, + "line": 6976, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 213103, + "end": 214102 + }, + "pattern_range": { + "start": 213149, + "end": 213160 + }, + "action_range": { + "start": 213162, + "end": 214101 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "f: EcxVecOperand", + "range": { + "start": 79767, + "end": 79803 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 79808, + "end": 79853 + }, + "inputs": [] + }, + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "vec: EcxVecOperandBase", + "range": { + "start": 79858, + "end": 79900 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 79905, + "end": 79952 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "x1: EcxOperand", + "range": { + "start": 79957, + "end": 79991 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t2: EcxVO", + "range": { + "start": 79996, + "end": 80025 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstVecOperand_helper", + "label": "_t1: EcxSubstVecOperand_helper", + "range": { + "start": 80030, + "end": 80084 + }, + "inputs": [ + "_t2", + "x1" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t4: EcxVO", + "range": { + "start": 80089, + "end": 80118 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxVecOperand_length", + "label": "_f3: EcxVecOperand_length", + "range": { + "start": 80123, + "end": 80167 + }, + "inputs": [ + "_t4" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x1", + "kind": "operand", + "index": 1 + }, + { + "from": "_t4", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "_t4", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "f", + "i", + "vec", + "x0", + "x1", + "_t1", + "_t2", + "_f3", + "_t4" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 80419, + "end": 80421 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "i.handle().eq(&_t1.handle_a3())", + "semantic_text": "i == _t1.a3", + "referenced_vars": [ + "_t1", + "i" + ], + "range": { + "start": 80439, + "end": 80441 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 80459, + "end": 80461 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "i.handle().lt(&_f3.handle())", + "semantic_text": "i < _f3", + "referenced_vars": [ + "_f3", + "i" + ], + "range": { + "start": 80479, + "end": 80481 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@213192:213218", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_vo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 213192, + "end": 213218 + } + }, + { + "id": "effect_1", + "effect_id": "effect@213237:213388", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_subst_vec_operand_helper(\n t2,\n ctx.devalue(pat.x0),\n pat.x1,\n ctx.devalue(pat.i),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "i", + "x0", + "x1" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 213237, + "end": 213388 + } + }, + { + "id": "effect_2", + "effect_id": "effect@213407:213433", + "bound_var": "t7", + "source_text": "ctx.insert_ecx_vo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 213407, + "end": 213433 + } + }, + { + "id": "effect_3", + "effect_id": "effect@213452:213506", + "bound_var": "t6", + "source_text": "ctx.insert_ecx_vec_operand_get(t7, ctx.devalue(pat.i))", + "semantic_text": null, + "referenced_pat_vars": [ + "i" + ], + "referenced_action_vars": [ + "t7" + ], + "range": { + "start": 213452, + "end": 213506 + } + }, + { + "id": "effect_4", + "effect_id": "effect@213525:213586", + "bound_var": "t5", + "source_text": "ctx.insert_ecx_subst_operand(t6, ctx.devalue(pat.x0), pat.x1)", + "semantic_text": null, + "referenced_pat_vars": [ + "x0", + "x1" + ], + "referenced_action_vars": [ + "t6" + ], + "range": { + "start": 213525, + "end": 213586 + } + }, + { + "id": "effect_5", + "effect_id": "effect@213605:213887", + "bound_var": "t4", + "source_text": "ctx.insert_ecx_vo(\n ctx.intern_container::>(vec_set::<\n EcxOperand,\n >(\n &*ctx.devalue(pat.vec),\n ctx.devalue(pat.i),\n t5.erase(),\n )),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "i", + "vec" + ], + "referenced_action_vars": [ + "t5" + ], + "range": { + "start": 213605, + "end": 213887 + } + }, + { + "id": "effect_6", + "effect_id": "effect@213906:214067", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_subst_vec_operand_helper(\n t4,\n ctx.devalue(pat.x0),\n pat.x1,\n (ctx.devalue(pat.i) + 1_i64),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "i", + "x0", + "x1" + ], + "referenced_action_vars": [ + "t4" + ], + "range": { + "start": 213906, + "end": 214067 + } + }, + { + "id": "effect_7", + "effect_id": "effect@214077:214094", + "bound_var": null, + "source_text": "ctx.union(t1, t3)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t1", + "t3" + ], + "range": { + "start": 214077, + "end": 214094 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0088", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstVecOperand_helper", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxVecOperand_length", + "plain_source": "upright(\"EcxVecOperand_length\")(upright(\"VO\")(upright(\"vec\")))", + "colored_source": "upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")", + "i == upright(\"_t1.a3\")", + "f == upright(\"_t1\")", + "i < upright(\"_f3\")" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(i \\ x_0 \\ upright(\"_t1\") \\ upright(\"VO\")(upright(\"vec\")) \\ upright(\"EcxVecOperand_length\")(upright(\"VO\")(upright(\"vec\"))) \\ upright(\"VO\")(upright(\"vec\")), upright(\"no conclusion\")) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ i == upright(\"_t1.a3\") \\ f == upright(\"_t1\") \\ i < upright(\"_f3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $] \\ upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], upright(\"no conclusion\")) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ i == upright(\"_t1.a3\") \\ f == upright(\"_t1\") \\ i < upright(\"_f3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7004_5_MyTxEggccExtraction_add_rule__r0089__76cc63e77b38b11d", + "display_name": "r0089", + "rule_name": "r0089", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 214108, + "line": 7004, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 214108, + "end": 214473 + }, + "pattern_range": { + "start": 214154, + "end": 214165 + }, + "action_range": { + "start": 214167, + "end": 214472 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "f: EcxVecOperand", + "range": { + "start": 80773, + "end": 80809 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 80814, + "end": 80859 + }, + "inputs": [] + }, + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "vec: EcxVecOperandBase", + "range": { + "start": 80864, + "end": 80906 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 80911, + "end": 80958 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "x1: EcxOperand", + "range": { + "start": 80963, + "end": 80997 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t2: EcxVO", + "range": { + "start": 81002, + "end": 81031 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstVecOperand_helper", + "label": "_t1: EcxSubstVecOperand_helper", + "range": { + "start": 81036, + "end": 81090 + }, + "inputs": [ + "_t2", + "x1" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t4: EcxVO", + "range": { + "start": 81095, + "end": 81124 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxVecOperand_length", + "label": "_f3: EcxVecOperand_length", + "range": { + "start": 81129, + "end": 81173 + }, + "inputs": [ + "_t4" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x1", + "kind": "operand", + "index": 1 + }, + { + "from": "_t4", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "_t4", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "f", + "i", + "vec", + "x0", + "x1", + "_t1", + "_t2", + "_f3", + "_t4" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 81425, + "end": 81427 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "i.handle().eq(&_t1.handle_a3())", + "semantic_text": "i == _t1.a3", + "referenced_vars": [ + "_t1", + "i" + ], + "range": { + "start": 81445, + "end": 81447 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 81465, + "end": 81467 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "i.handle().eq(&_f3.handle())", + "semantic_text": "i == _f3", + "referenced_vars": [ + "_f3", + "i" + ], + "range": { + "start": 81485, + "end": 81487 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@214197:214223", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_vo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 214197, + "end": 214223 + } + }, + { + "id": "effect_1", + "effect_id": "effect@214242:214393", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_subst_vec_operand_helper(\n t2,\n ctx.devalue(pat.x0),\n pat.x1,\n ctx.devalue(pat.i),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "i", + "x0", + "x1" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 214242, + "end": 214393 + } + }, + { + "id": "effect_2", + "effect_id": "effect@214412:214438", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_vo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 214412, + "end": 214438 + } + }, + { + "id": "effect_3", + "effect_id": "effect@214448:214465", + "bound_var": null, + "source_text": "ctx.union(t1, t3)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t1", + "t3" + ], + "range": { + "start": 214448, + "end": 214465 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0089", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstVecOperand_helper", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxVecOperand_length", + "plain_source": "upright(\"EcxVecOperand_length\")(upright(\"VO\")(upright(\"vec\")))", + "colored_source": "upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")", + "i == upright(\"_t1.a3\")", + "f == upright(\"_t1\")", + "i == upright(\"_f3\")" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(i \\ x_0 \\ upright(\"_t1\") \\ upright(\"VO\")(upright(\"vec\")) \\ upright(\"EcxVecOperand_length\")(upright(\"VO\")(upright(\"vec\"))) \\ upright(\"VO\")(upright(\"vec\")), upright(\"no conclusion\")) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ i == upright(\"_t1.a3\") \\ f == upright(\"_t1\") \\ i == upright(\"_f3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $] \\ upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], upright(\"no conclusion\")) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ i == upright(\"_t1.a3\") \\ f == upright(\"_t1\") \\ i == upright(\"_f3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7015_5_MyTxEggccExtraction_add_rule__r0090__134fc475096b1621", + "display_name": "r0090", + "rule_name": "r0090", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 214479, + "line": 7015, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 214479, + "end": 214755 + }, + "pattern_range": { + "start": 214525, + "end": 214536 + }, + "action_range": { + "start": 214538, + "end": 214754 + } + }, + "nodes": [ + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "vec: EcxVecVecOperand", + "range": { + "start": 81694, + "end": 81735 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 81740, + "end": 81787 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "x1: EcxOperand", + "range": { + "start": 81792, + "end": 81826 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstVecVecOperand", + "label": "_t1: EcxSubstVecVecOperand", + "range": { + "start": 81831, + "end": 81881 + }, + "inputs": [ + "vec", + "x1" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x1", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "vec", + "x0", + "x1", + "_t1" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 81971, + "end": 81973 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@214568:214715", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_subst_vec_vec_operand_helper(\n pat.vec,\n ctx.devalue(pat.x0),\n pat.x1,\n 0_i64,\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "vec", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 214568, + "end": 214715 + } + }, + { + "id": "effect_1", + "effect_id": "effect@214725:214747", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 214725, + "end": 214747 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0090", + "premises": [ + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstVecVecOperand", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"EcxSubstVecVecOperandHelper\")(upright(\"vec\"), x_0, x_1, 0)", + "colored_source": "upright(\"EcxSubstVecVecOperandHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $], #text(fill: rgb(\"#B86A5B\"))[$ 0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstVecVecOperand", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"EcxSubstVecVecOperandHelper\")(upright(\"vec\"), x_0, x_1, 0)", + "colored_source": "upright(\"EcxSubstVecVecOperandHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $], #text(fill: rgb(\"#B86A5B\"))[$ 0 $])" + } + } + ], + "formula_source": { + "plain": "frac(x_0 \\ upright(\"_t1\"), upright(\"_t1\") arrow.r.double upright(\"EcxSubstVecVecOperandHelper\")(upright(\"vec\"), x_0, x_1, 0)) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double upright(\"EcxSubstVecVecOperandHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $], #text(fill: rgb(\"#B86A5B\"))[$ 0 $])) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7024_5_MyTxEggccExtraction_add_rule__r0091__590967a23428b746", + "display_name": "r0091", + "rule_name": "r0091", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 214761, + "line": 7024, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 214761, + "end": 215788 + }, + "pattern_range": { + "start": 214807, + "end": 214818 + }, + "action_range": { + "start": 214820, + "end": 215787 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "f: EcxVecVecOperand", + "range": { + "start": 82276, + "end": 82315 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 82320, + "end": 82365 + }, + "inputs": [] + }, + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperandBase", + "label": "vec: EcxVecVecOperandBase", + "range": { + "start": 82370, + "end": 82415 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 82420, + "end": 82467 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "x1: EcxOperand", + "range": { + "start": 82472, + "end": 82506 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t2: EcxVVO", + "range": { + "start": 82511, + "end": 82541 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstVecVecOperand_helper", + "label": "_t1: EcxSubstVecVecOperand_helper", + "range": { + "start": 82546, + "end": 82603 + }, + "inputs": [ + "_t2", + "x1" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t4: EcxVVO", + "range": { + "start": 82608, + "end": 82638 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxVecVecOperand_length", + "label": "_f3: EcxVecVecOperand_length", + "range": { + "start": 82643, + "end": 82690 + }, + "inputs": [ + "_t4" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x1", + "kind": "operand", + "index": 1 + }, + { + "from": "_t4", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "_t4", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "f", + "i", + "vec", + "x0", + "x1", + "_t1", + "_t2", + "_f3", + "_t4" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 82942, + "end": 82944 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "i.handle().eq(&_t1.handle_a3())", + "semantic_text": "i == _t1.a3", + "referenced_vars": [ + "_t1", + "i" + ], + "range": { + "start": 82962, + "end": 82964 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 82982, + "end": 82984 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "i.handle().lt(&_f3.handle())", + "semantic_text": "i < _f3", + "referenced_vars": [ + "_f3", + "i" + ], + "range": { + "start": 83002, + "end": 83004 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@214850:214877", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_vvo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 214850, + "end": 214877 + } + }, + { + "id": "effect_1", + "effect_id": "effect@214896:215051", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_subst_vec_vec_operand_helper(\n t2,\n ctx.devalue(pat.x0),\n pat.x1,\n ctx.devalue(pat.i),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "i", + "x0", + "x1" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 214896, + "end": 215051 + } + }, + { + "id": "effect_2", + "effect_id": "effect@215070:215097", + "bound_var": "t7", + "source_text": "ctx.insert_ecx_vvo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 215070, + "end": 215097 + } + }, + { + "id": "effect_3", + "effect_id": "effect@215116:215174", + "bound_var": "t6", + "source_text": "ctx.insert_ecx_vec_vec_operand_get(t7, ctx.devalue(pat.i))", + "semantic_text": null, + "referenced_pat_vars": [ + "i" + ], + "referenced_action_vars": [ + "t7" + ], + "range": { + "start": 215116, + "end": 215174 + } + }, + { + "id": "effect_4", + "effect_id": "effect@215193:215258", + "bound_var": "t5", + "source_text": "ctx.insert_ecx_subst_vec_operand(t6, ctx.devalue(pat.x0), pat.x1)", + "semantic_text": null, + "referenced_pat_vars": [ + "x0", + "x1" + ], + "referenced_action_vars": [ + "t6" + ], + "range": { + "start": 215193, + "end": 215258 + } + }, + { + "id": "effect_5", + "effect_id": "effect@215277:215569", + "bound_var": "t4", + "source_text": "ctx.insert_ecx_vvo(\n ctx.intern_container::>(vec_set::<\n EcxVecOperand,\n >(\n &*ctx.devalue(pat.vec),\n ctx.devalue(pat.i),\n t5.erase(),\n )),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "i", + "vec" + ], + "referenced_action_vars": [ + "t5" + ], + "range": { + "start": 215277, + "end": 215569 + } + }, + { + "id": "effect_6", + "effect_id": "effect@215588:215753", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_subst_vec_vec_operand_helper(\n t4,\n ctx.devalue(pat.x0),\n pat.x1,\n (ctx.devalue(pat.i) + 1_i64),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "i", + "x0", + "x1" + ], + "referenced_action_vars": [ + "t4" + ], + "range": { + "start": 215588, + "end": 215753 + } + }, + { + "id": "effect_7", + "effect_id": "effect@215763:215780", + "bound_var": null, + "source_text": "ctx.union(t1, t3)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t1", + "t3" + ], + "range": { + "start": 215763, + "end": 215780 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0091", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstVecVecOperand_helper", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxVecVecOperand_length", + "plain_source": "upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(upright(\"vec\")))", + "colored_source": "upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")", + "i == upright(\"_t1.a3\")", + "f == upright(\"_t1\")", + "i < upright(\"_f3\")" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(i \\ x_0 \\ upright(\"_t1\") \\ upright(\"VVO\")(upright(\"vec\")) \\ upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(upright(\"vec\"))) \\ upright(\"VVO\")(upright(\"vec\")), upright(\"no conclusion\")) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ i == upright(\"_t1.a3\") \\ f == upright(\"_t1\") \\ i < upright(\"_f3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $] \\ upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], upright(\"no conclusion\")) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ i == upright(\"_t1.a3\") \\ f == upright(\"_t1\") \\ i < upright(\"_f3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7052_5_MyTxEggccExtraction_add_rule__r0092__e6ed35329b1de262", + "display_name": "r0092", + "rule_name": "r0092", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 215794, + "line": 7052, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 215794, + "end": 216165 + }, + "pattern_range": { + "start": 215840, + "end": 215851 + }, + "action_range": { + "start": 215853, + "end": 216164 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "f: EcxVecVecOperand", + "range": { + "start": 83307, + "end": 83346 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 83351, + "end": 83396 + }, + "inputs": [] + }, + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperandBase", + "label": "vec: EcxVecVecOperandBase", + "range": { + "start": 83401, + "end": 83446 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 83451, + "end": 83498 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "x1: EcxOperand", + "range": { + "start": 83503, + "end": 83537 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t2: EcxVVO", + "range": { + "start": 83542, + "end": 83572 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstVecVecOperand_helper", + "label": "_t1: EcxSubstVecVecOperand_helper", + "range": { + "start": 83577, + "end": 83634 + }, + "inputs": [ + "_t2", + "x1" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t4: EcxVVO", + "range": { + "start": 83639, + "end": 83669 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxVecVecOperand_length", + "label": "_f3: EcxVecVecOperand_length", + "range": { + "start": 83674, + "end": 83721 + }, + "inputs": [ + "_t4" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x1", + "kind": "operand", + "index": 1 + }, + { + "from": "_t4", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "_t4", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "f", + "i", + "vec", + "x0", + "x1", + "_t1", + "_t2", + "_f3", + "_t4" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 83973, + "end": 83975 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "i.handle().eq(&_t1.handle_a3())", + "semantic_text": "i == _t1.a3", + "referenced_vars": [ + "_t1", + "i" + ], + "range": { + "start": 83993, + "end": 83995 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 84013, + "end": 84015 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "i.handle().eq(&_f3.handle())", + "semantic_text": "i == _f3", + "referenced_vars": [ + "_f3", + "i" + ], + "range": { + "start": 84033, + "end": 84035 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@215883:215910", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_vvo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 215883, + "end": 215910 + } + }, + { + "id": "effect_1", + "effect_id": "effect@215929:216084", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_subst_vec_vec_operand_helper(\n t2,\n ctx.devalue(pat.x0),\n pat.x1,\n ctx.devalue(pat.i),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "i", + "x0", + "x1" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 215929, + "end": 216084 + } + }, + { + "id": "effect_2", + "effect_id": "effect@216103:216130", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_vvo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 216103, + "end": 216130 + } + }, + { + "id": "effect_3", + "effect_id": "effect@216140:216157", + "bound_var": null, + "source_text": "ctx.union(t1, t3)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t1", + "t3" + ], + "range": { + "start": 216140, + "end": 216157 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0092", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstVecVecOperand_helper", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxVecVecOperand_length", + "plain_source": "upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(upright(\"vec\")))", + "colored_source": "upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")", + "i == upright(\"_t1.a3\")", + "f == upright(\"_t1\")", + "i == upright(\"_f3\")" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(i \\ x_0 \\ upright(\"_t1\") \\ upright(\"VVO\")(upright(\"vec\")) \\ upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(upright(\"vec\"))) \\ upright(\"VVO\")(upright(\"vec\")), upright(\"no conclusion\")) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ i == upright(\"_t1.a3\") \\ f == upright(\"_t1\") \\ i == upright(\"_f3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $] \\ upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], upright(\"no conclusion\")) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ i == upright(\"_t1.a3\") \\ f == upright(\"_t1\") \\ i == upright(\"_f3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7063_5_MyTxEggccExtraction_add_rule__r0093__78582db946f021ed", + "display_name": "r0093", + "rule_name": "r0093", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 216171, + "line": 7063, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 216171, + "end": 216466 + }, + "pattern_range": { + "start": 216217, + "end": 216228 + }, + "action_range": { + "start": 216230, + "end": 216465 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 84272, + "end": 84305 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 84310, + "end": 84343 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty: EcxType", + "range": { + "start": 84348, + "end": 84379 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "x0: EcxVecOperand", + "range": { + "start": 84384, + "end": 84421 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxbadd", + "label": "_t2: Ecxbadd", + "range": { + "start": 84426, + "end": 84464 + }, + "inputs": [ + "ty", + "a", + "b" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstExprAll", + "label": "_t1: EcxSubstExprAll", + "range": { + "start": 84469, + "end": 84513 + }, + "inputs": [ + "_t2", + "x0" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "a", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "b", + "kind": "operand", + "index": 2 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "a", + "b", + "ty", + "x0", + "_t1", + "_t2" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@216260:216307", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_operand_all(pat.a, pat.x0)", + "semantic_text": null, + "referenced_pat_vars": [ + "a", + "x0" + ], + "referenced_action_vars": [], + "range": { + "start": 216260, + "end": 216307 + } + }, + { + "id": "effect_1", + "effect_id": "effect@216326:216373", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_subst_operand_all(pat.b, pat.x0)", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "x0" + ], + "referenced_action_vars": [], + "range": { + "start": 216326, + "end": 216373 + } + }, + { + "id": "effect_2", + "effect_id": "effect@216392:216426", + "bound_var": "t1", + "source_text": "ctx.insert_ecxbadd(pat.ty, t2, t3)", + "semantic_text": null, + "referenced_pat_vars": [ + "ty" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 216392, + "end": 216426 + } + }, + { + "id": "effect_3", + "effect_id": "effect@216436:216458", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 216436, + "end": 216458 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0093", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxSubstExprAll", + "plain_source": "upright(\"SubstExprAll\")((upright(\"badd\")(upright(\"ty\"), a, b)), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxbadd", + "plain_source": "upright(\"badd\")(upright(\"ty\"), a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"SubstOperandAll\")(a, x_0)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"SubstOperandAll\")(b, x_0)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"badd\")(upright(\"ty\"), (upright(\"SubstOperandAll\")(a, x_0)), (upright(\"SubstOperandAll\")(b, x_0)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_3", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstExprAll", + "plain_source": "upright(\"SubstExprAll\")((upright(\"badd\")(upright(\"ty\"), a, b)), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + "to": { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"badd\")(upright(\"ty\"), (upright(\"SubstOperandAll\")(a, x_0)), (upright(\"SubstOperandAll\")(b, x_0)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"SubstExprAll\")((upright(\"badd\")(upright(\"ty\"), a, b)), x_0) \\ upright(\"badd\")(upright(\"ty\"), a, b), upright(\"SubstExprAll\")((upright(\"badd\")(upright(\"ty\"), a, b)), x_0) arrow.r.double upright(\"badd\")(upright(\"ty\"), (upright(\"SubstOperandAll\")(a, x_0)), (upright(\"SubstOperandAll\")(b, x_0)))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $])) $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7069_5_MyTxEggccExtraction_add_rule__r0094__f8193fed7a23fdce", + "display_name": "r0094", + "rule_name": "r0094", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 216472, + "line": 7069, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 216472, + "end": 216767 + }, + "pattern_range": { + "start": 216518, + "end": 216529 + }, + "action_range": { + "start": 216531, + "end": 216766 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 84790, + "end": 84823 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 84828, + "end": 84861 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty: EcxType", + "range": { + "start": 84866, + "end": 84897 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "x0: EcxVecOperand", + "range": { + "start": 84902, + "end": 84939 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxbsub", + "label": "_t2: Ecxbsub", + "range": { + "start": 84944, + "end": 84982 + }, + "inputs": [ + "ty", + "a", + "b" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstExprAll", + "label": "_t1: EcxSubstExprAll", + "range": { + "start": 84987, + "end": 85031 + }, + "inputs": [ + "_t2", + "x0" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "a", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "b", + "kind": "operand", + "index": 2 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "a", + "b", + "ty", + "x0", + "_t1", + "_t2" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@216561:216608", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_operand_all(pat.a, pat.x0)", + "semantic_text": null, + "referenced_pat_vars": [ + "a", + "x0" + ], + "referenced_action_vars": [], + "range": { + "start": 216561, + "end": 216608 + } + }, + { + "id": "effect_1", + "effect_id": "effect@216627:216674", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_subst_operand_all(pat.b, pat.x0)", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "x0" + ], + "referenced_action_vars": [], + "range": { + "start": 216627, + "end": 216674 + } + }, + { + "id": "effect_2", + "effect_id": "effect@216693:216727", + "bound_var": "t1", + "source_text": "ctx.insert_ecxbsub(pat.ty, t2, t3)", + "semantic_text": null, + "referenced_pat_vars": [ + "ty" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 216693, + "end": 216727 + } + }, + { + "id": "effect_3", + "effect_id": "effect@216737:216759", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 216737, + "end": 216759 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0094", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxSubstExprAll", + "plain_source": "upright(\"SubstExprAll\")((upright(\"bsub\")(upright(\"ty\"), a, b)), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxbsub", + "plain_source": "upright(\"bsub\")(upright(\"ty\"), a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"SubstOperandAll\")(a, x_0)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"SubstOperandAll\")(b, x_0)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"bsub\")(upright(\"ty\"), (upright(\"SubstOperandAll\")(a, x_0)), (upright(\"SubstOperandAll\")(b, x_0)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_3", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstExprAll", + "plain_source": "upright(\"SubstExprAll\")((upright(\"bsub\")(upright(\"ty\"), a, b)), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + "to": { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"bsub\")(upright(\"ty\"), (upright(\"SubstOperandAll\")(a, x_0)), (upright(\"SubstOperandAll\")(b, x_0)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"SubstExprAll\")((upright(\"bsub\")(upright(\"ty\"), a, b)), x_0) \\ upright(\"bsub\")(upright(\"ty\"), a, b), upright(\"SubstExprAll\")((upright(\"bsub\")(upright(\"ty\"), a, b)), x_0) arrow.r.double upright(\"bsub\")(upright(\"ty\"), (upright(\"SubstOperandAll\")(a, x_0)), (upright(\"SubstOperandAll\")(b, x_0)))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $])) $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7075_5_MyTxEggccExtraction_add_rule__r0095__7cbaf98c7b22aa7c", + "display_name": "r0095", + "rule_name": "r0095", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 216773, + "line": 7075, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 216773, + "end": 217068 + }, + "pattern_range": { + "start": 216819, + "end": 216830 + }, + "action_range": { + "start": 216832, + "end": 217067 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 85308, + "end": 85341 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 85346, + "end": 85379 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty: EcxType", + "range": { + "start": 85384, + "end": 85415 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "x0: EcxVecOperand", + "range": { + "start": 85420, + "end": 85457 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxbmul", + "label": "_t2: Ecxbmul", + "range": { + "start": 85462, + "end": 85500 + }, + "inputs": [ + "ty", + "a", + "b" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstExprAll", + "label": "_t1: EcxSubstExprAll", + "range": { + "start": 85505, + "end": 85549 + }, + "inputs": [ + "_t2", + "x0" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "a", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "b", + "kind": "operand", + "index": 2 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "a", + "b", + "ty", + "x0", + "_t1", + "_t2" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@216862:216909", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_operand_all(pat.a, pat.x0)", + "semantic_text": null, + "referenced_pat_vars": [ + "a", + "x0" + ], + "referenced_action_vars": [], + "range": { + "start": 216862, + "end": 216909 + } + }, + { + "id": "effect_1", + "effect_id": "effect@216928:216975", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_subst_operand_all(pat.b, pat.x0)", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "x0" + ], + "referenced_action_vars": [], + "range": { + "start": 216928, + "end": 216975 + } + }, + { + "id": "effect_2", + "effect_id": "effect@216994:217028", + "bound_var": "t1", + "source_text": "ctx.insert_ecxbmul(pat.ty, t2, t3)", + "semantic_text": null, + "referenced_pat_vars": [ + "ty" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 216994, + "end": 217028 + } + }, + { + "id": "effect_3", + "effect_id": "effect@217038:217060", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 217038, + "end": 217060 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0095", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxSubstExprAll", + "plain_source": "upright(\"SubstExprAll\")((upright(\"bmul\")(upright(\"ty\"), a, b)), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxbmul", + "plain_source": "upright(\"bmul\")(upright(\"ty\"), a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"SubstOperandAll\")(a, x_0)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"SubstOperandAll\")(b, x_0)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"bmul\")(upright(\"ty\"), (upright(\"SubstOperandAll\")(a, x_0)), (upright(\"SubstOperandAll\")(b, x_0)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_3", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstExprAll", + "plain_source": "upright(\"SubstExprAll\")((upright(\"bmul\")(upright(\"ty\"), a, b)), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + "to": { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"bmul\")(upright(\"ty\"), (upright(\"SubstOperandAll\")(a, x_0)), (upright(\"SubstOperandAll\")(b, x_0)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"SubstExprAll\")((upright(\"bmul\")(upright(\"ty\"), a, b)), x_0) \\ upright(\"bmul\")(upright(\"ty\"), a, b), upright(\"SubstExprAll\")((upright(\"bmul\")(upright(\"ty\"), a, b)), x_0) arrow.r.double upright(\"bmul\")(upright(\"ty\"), (upright(\"SubstOperandAll\")(a, x_0)), (upright(\"SubstOperandAll\")(b, x_0)))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $])) $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7081_5_MyTxEggccExtraction_add_rule__r0096__4fd36799b650c4ea", + "display_name": "r0096", + "rule_name": "r0096", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 217074, + "line": 7081, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 217074, + "end": 217369 + }, + "pattern_range": { + "start": 217120, + "end": 217131 + }, + "action_range": { + "start": 217133, + "end": 217368 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 85826, + "end": 85859 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 85864, + "end": 85897 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty: EcxType", + "range": { + "start": 85902, + "end": 85933 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "x0: EcxVecOperand", + "range": { + "start": 85938, + "end": 85975 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxbdiv", + "label": "_t2: Ecxbdiv", + "range": { + "start": 85980, + "end": 86018 + }, + "inputs": [ + "ty", + "a", + "b" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstExprAll", + "label": "_t1: EcxSubstExprAll", + "range": { + "start": 86023, + "end": 86067 + }, + "inputs": [ + "_t2", + "x0" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "a", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "b", + "kind": "operand", + "index": 2 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "a", + "b", + "ty", + "x0", + "_t1", + "_t2" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@217163:217210", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_operand_all(pat.a, pat.x0)", + "semantic_text": null, + "referenced_pat_vars": [ + "a", + "x0" + ], + "referenced_action_vars": [], + "range": { + "start": 217163, + "end": 217210 + } + }, + { + "id": "effect_1", + "effect_id": "effect@217229:217276", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_subst_operand_all(pat.b, pat.x0)", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "x0" + ], + "referenced_action_vars": [], + "range": { + "start": 217229, + "end": 217276 + } + }, + { + "id": "effect_2", + "effect_id": "effect@217295:217329", + "bound_var": "t1", + "source_text": "ctx.insert_ecxbdiv(pat.ty, t2, t3)", + "semantic_text": null, + "referenced_pat_vars": [ + "ty" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 217295, + "end": 217329 + } + }, + { + "id": "effect_3", + "effect_id": "effect@217339:217361", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 217339, + "end": 217361 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0096", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxSubstExprAll", + "plain_source": "upright(\"SubstExprAll\")((upright(\"bdiv\")(upright(\"ty\"), a, b)), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxbdiv", + "plain_source": "upright(\"bdiv\")(upright(\"ty\"), a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"SubstOperandAll\")(a, x_0)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"SubstOperandAll\")(b, x_0)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"bdiv\")(upright(\"ty\"), (upright(\"SubstOperandAll\")(a, x_0)), (upright(\"SubstOperandAll\")(b, x_0)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_3", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstExprAll", + "plain_source": "upright(\"SubstExprAll\")((upright(\"bdiv\")(upright(\"ty\"), a, b)), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + "to": { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"bdiv\")(upright(\"ty\"), (upright(\"SubstOperandAll\")(a, x_0)), (upright(\"SubstOperandAll\")(b, x_0)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"SubstExprAll\")((upright(\"bdiv\")(upright(\"ty\"), a, b)), x_0) \\ upright(\"bdiv\")(upright(\"ty\"), a, b), upright(\"SubstExprAll\")((upright(\"bdiv\")(upright(\"ty\"), a, b)), x_0) arrow.r.double upright(\"bdiv\")(upright(\"ty\"), (upright(\"SubstOperandAll\")(a, x_0)), (upright(\"SubstOperandAll\")(b, x_0)))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $])) $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7087_5_MyTxEggccExtraction_add_rule__r0097__e0e408a0c02a071b", + "display_name": "r0097", + "rule_name": "r0097", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 217375, + "line": 7087, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 217375, + "end": 217669 + }, + "pattern_range": { + "start": 217421, + "end": 217432 + }, + "action_range": { + "start": 217434, + "end": 217668 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 86343, + "end": 86376 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 86381, + "end": 86414 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty: EcxType", + "range": { + "start": 86419, + "end": 86450 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "x0: EcxVecOperand", + "range": { + "start": 86455, + "end": 86492 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxblt", + "label": "_t2: Ecxblt", + "range": { + "start": 86497, + "end": 86534 + }, + "inputs": [ + "ty", + "a", + "b" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstExprAll", + "label": "_t1: EcxSubstExprAll", + "range": { + "start": 86539, + "end": 86583 + }, + "inputs": [ + "_t2", + "x0" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "a", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "b", + "kind": "operand", + "index": 2 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "a", + "b", + "ty", + "x0", + "_t1", + "_t2" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@217464:217511", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_operand_all(pat.a, pat.x0)", + "semantic_text": null, + "referenced_pat_vars": [ + "a", + "x0" + ], + "referenced_action_vars": [], + "range": { + "start": 217464, + "end": 217511 + } + }, + { + "id": "effect_1", + "effect_id": "effect@217530:217577", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_subst_operand_all(pat.b, pat.x0)", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "x0" + ], + "referenced_action_vars": [], + "range": { + "start": 217530, + "end": 217577 + } + }, + { + "id": "effect_2", + "effect_id": "effect@217596:217629", + "bound_var": "t1", + "source_text": "ctx.insert_ecxblt(pat.ty, t2, t3)", + "semantic_text": null, + "referenced_pat_vars": [ + "ty" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 217596, + "end": 217629 + } + }, + { + "id": "effect_3", + "effect_id": "effect@217639:217661", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 217639, + "end": 217661 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0097", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxSubstExprAll", + "plain_source": "upright(\"SubstExprAll\")((upright(\"blt\")(upright(\"ty\"), a, b)), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxblt", + "plain_source": "upright(\"blt\")(upright(\"ty\"), a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"SubstOperandAll\")(a, x_0)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"SubstOperandAll\")(b, x_0)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"blt\")(upright(\"ty\"), (upright(\"SubstOperandAll\")(a, x_0)), (upright(\"SubstOperandAll\")(b, x_0)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_3", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstExprAll", + "plain_source": "upright(\"SubstExprAll\")((upright(\"blt\")(upright(\"ty\"), a, b)), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + "to": { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"blt\")(upright(\"ty\"), (upright(\"SubstOperandAll\")(a, x_0)), (upright(\"SubstOperandAll\")(b, x_0)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"SubstExprAll\")((upright(\"blt\")(upright(\"ty\"), a, b)), x_0) \\ upright(\"blt\")(upright(\"ty\"), a, b), upright(\"SubstExprAll\")((upright(\"blt\")(upright(\"ty\"), a, b)), x_0) arrow.r.double upright(\"blt\")(upright(\"ty\"), (upright(\"SubstOperandAll\")(a, x_0)), (upright(\"SubstOperandAll\")(b, x_0)))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $])) $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7093_5_MyTxEggccExtraction_add_rule__r0098__0c162d432ec5f417", + "display_name": "r0098", + "rule_name": "r0098", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 217675, + "line": 7093, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 217675, + "end": 217850 + }, + "pattern_range": { + "start": 217721, + "end": 217732 + }, + "action_range": { + "start": 217734, + "end": 217849 + } + }, + "nodes": [ + { + "id": "lit", + "kind": "query_leaf", + "dsl_type": "EcxLiteral", + "label": "lit: EcxLiteral", + "range": { + "start": 86866, + "end": 86901 + }, + "inputs": [] + }, + { + "id": "ops", + "kind": "query_leaf", + "dsl_type": "EcxConstOps", + "label": "ops: EcxConstOps", + "range": { + "start": 86906, + "end": 86942 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty: EcxType", + "range": { + "start": 86947, + "end": 86978 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "x0: EcxVecOperand", + "range": { + "start": 86983, + "end": 87020 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxConst", + "label": "_t2: EcxConst", + "range": { + "start": 87025, + "end": 87068 + }, + "inputs": [ + "ty", + "ops", + "lit" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstExprAll", + "label": "_t1: EcxSubstExprAll", + "range": { + "start": 87073, + "end": 87117 + }, + "inputs": [ + "_t2", + "x0" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "ops", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "lit", + "kind": "operand", + "index": 2 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "lit", + "ops", + "ty", + "x0", + "_t1", + "_t2" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@217764:217810", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_const(pat.ty, pat.ops, pat.lit)", + "semantic_text": null, + "referenced_pat_vars": [ + "lit", + "ops", + "ty" + ], + "referenced_action_vars": [], + "range": { + "start": 217764, + "end": 217810 + } + }, + { + "id": "effect_1", + "effect_id": "effect@217820:217842", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 217820, + "end": 217842 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0098", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxSubstExprAll", + "plain_source": "upright(\"SubstExprAll\")((upright(\"Const\")(upright(\"ty\"), upright(\"ops\"), upright(\"lit\"))), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lit\") $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxConst", + "plain_source": "upright(\"Const\")(upright(\"ty\"), upright(\"ops\"), upright(\"lit\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lit\") $]) $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"Const\")(upright(\"ty\"), upright(\"ops\"), upright(\"lit\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lit\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstExprAll", + "plain_source": "upright(\"SubstExprAll\")((upright(\"Const\")(upright(\"ty\"), upright(\"ops\"), upright(\"lit\"))), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lit\") $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"Const\")(upright(\"ty\"), upright(\"ops\"), upright(\"lit\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lit\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"SubstExprAll\")((upright(\"Const\")(upright(\"ty\"), upright(\"ops\"), upright(\"lit\"))), x_0) \\ upright(\"Const\")(upright(\"ty\"), upright(\"ops\"), upright(\"lit\")), upright(\"SubstExprAll\")((upright(\"Const\")(upright(\"ty\"), upright(\"ops\"), upright(\"lit\"))), x_0) arrow.r.double upright(\"Const\")(upright(\"ty\"), upright(\"ops\"), upright(\"lit\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lit\") $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lit\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lit\") $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lit\") $]) $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7097_5_MyTxEggccExtraction_add_rule__r0099__6585c73fc128bc48", + "display_name": "r0099", + "rule_name": "r0099", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 217856, + "line": 7097, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 217856, + "end": 218134 + }, + "pattern_range": { + "start": 217902, + "end": 217913 + }, + "action_range": { + "start": 217915, + "end": 218133 + } + }, + "nodes": [ + { + "id": "args", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "args: EcxVecOperand", + "range": { + "start": 87423, + "end": 87462 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query", + "dsl_type": "", + "label": "f: ", + "range": { + "start": 87467, + "end": 87515 + }, + "inputs": [] + }, + { + "id": "n_outs", + "kind": "query", + "dsl_type": "", + "label": "n_outs: ", + "range": { + "start": 87520, + "end": 87575 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxOptionType", + "label": "ty: EcxOptionType", + "range": { + "start": 87580, + "end": 87617 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "x0: EcxVecOperand", + "range": { + "start": 87622, + "end": 87659 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxCall", + "label": "_t2: EcxCall", + "range": { + "start": 87664, + "end": 87701 + }, + "inputs": [ + "ty", + "args" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstExprAll", + "label": "_t1: EcxSubstExprAll", + "range": { + "start": 87706, + "end": 87750 + }, + "inputs": [ + "_t2", + "x0" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "args", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "args", + "f", + "n_outs", + "ty", + "x0", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "f.handle().eq(&_t2.handle_a1())", + "semantic_text": "f == _t2.a1", + "referenced_vars": [ + "_t2", + "f" + ], + "range": { + "start": 87916, + "end": 87918 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "n_outs.handle().eq(&_t2.handle_a3())", + "semantic_text": "n_outs == _t2.a3", + "referenced_vars": [ + "_t2", + "n_outs" + ], + "range": { + "start": 87936, + "end": 87938 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@217945:217999", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_vec_operand_all(pat.args, pat.x0)", + "semantic_text": null, + "referenced_pat_vars": [ + "args", + "x0" + ], + "referenced_action_vars": [], + "range": { + "start": 217945, + "end": 217999 + } + }, + { + "id": "effect_1", + "effect_id": "effect@218018:218094", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_call(pat.ty, ctx.devalue(pat.f), t2, ctx.devalue(pat.n_outs))", + "semantic_text": null, + "referenced_pat_vars": [ + "f", + "n_outs", + "ty" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 218018, + "end": 218094 + } + }, + { + "id": "effect_2", + "effect_id": "effect@218104:218126", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 218104, + "end": 218126 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0099", + "premises": [ + { + "target_id": "f", + "label": "f: ", + "plain_source": "f", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ f $]" + }, + { + "target_id": "n_outs", + "label": "n_outs: ", + "plain_source": "upright(\"n_outs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"n_outs\") $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstExprAll", + "plain_source": "upright(\"SubstExprAll\")(upright(\"_t2\"), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxCall", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + } + ], + "side_conditions": [ + "f == upright(\"_t2.a1\")", + "upright(\"n_outs\") == upright(\"_t2.a3\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"SubstVecOperandAll\")(upright(\"args\"), x_0)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"args\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"Call\")(upright(\"ty\"), f, (upright(\"SubstVecOperandAll\")(upright(\"args\"), x_0)), upright(\"n_outs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Call\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ f $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"args\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"n_outs\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstExprAll", + "plain_source": "upright(\"SubstExprAll\")(upright(\"_t2\"), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + "to": { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"Call\")(upright(\"ty\"), f, (upright(\"SubstVecOperandAll\")(upright(\"args\"), x_0)), upright(\"n_outs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Call\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ f $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"args\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"n_outs\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(f \\ upright(\"n_outs\") \\ upright(\"SubstExprAll\")(upright(\"_t2\"), x_0) \\ upright(\"_t2\"), upright(\"SubstExprAll\")(upright(\"_t2\"), x_0) arrow.r.double upright(\"Call\")(upright(\"ty\"), f, (upright(\"SubstVecOperandAll\")(upright(\"args\"), x_0)), upright(\"n_outs\"))) quad upright(\"if\") quad f == upright(\"_t2.a1\") \\ upright(\"n_outs\") == upright(\"_t2.a3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ f $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"n_outs\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Call\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ f $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"args\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"n_outs\") $]) $]) quad upright(\"if\") quad f == upright(\"_t2.a1\") \\ upright(\"n_outs\") == upright(\"_t2.a3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7102_5_MyTxEggccExtraction_add_rule__r0100__1f83fad7a368dc2c", + "display_name": "r0100", + "rule_name": "r0100", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 218140, + "line": 7102, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 218140, + "end": 218429 + }, + "pattern_range": { + "start": 218186, + "end": 218197 + }, + "action_range": { + "start": 218199, + "end": 218428 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 88159, + "end": 88192 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 88197, + "end": 88230 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "x0: EcxVecOperand", + "range": { + "start": 88235, + "end": 88272 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxPRINT", + "label": "_t2: EcxPRINT", + "range": { + "start": 88277, + "end": 88311 + }, + "inputs": [ + "a", + "b" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstExprAll", + "label": "_t1: EcxSubstExprAll", + "range": { + "start": 88316, + "end": 88360 + }, + "inputs": [ + "_t2", + "x0" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "a", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "b", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "a", + "b", + "x0", + "_t1", + "_t2" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@218229:218276", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_operand_all(pat.a, pat.x0)", + "semantic_text": null, + "referenced_pat_vars": [ + "a", + "x0" + ], + "referenced_action_vars": [], + "range": { + "start": 218229, + "end": 218276 + } + }, + { + "id": "effect_1", + "effect_id": "effect@218295:218342", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_subst_operand_all(pat.b, pat.x0)", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "x0" + ], + "referenced_action_vars": [], + "range": { + "start": 218295, + "end": 218342 + } + }, + { + "id": "effect_2", + "effect_id": "effect@218361:218389", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_print(t2, t3)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 218361, + "end": 218389 + } + }, + { + "id": "effect_3", + "effect_id": "effect@218399:218421", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 218399, + "end": 218421 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0100", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxSubstExprAll", + "plain_source": "upright(\"SubstExprAll\")((upright(\"PRINT\")(a, b)), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PRINT\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxPRINT", + "plain_source": "upright(\"PRINT\")(a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PRINT\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"SubstOperandAll\")(a, x_0)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"SubstOperandAll\")(b, x_0)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"EcxPrint\")(upright(\"SubstOperandAll\")(a, x_0), upright(\"SubstOperandAll\")(b, x_0))", + "colored_source": "upright(\"EcxPrint\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_3", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstExprAll", + "plain_source": "upright(\"SubstExprAll\")((upright(\"PRINT\")(a, b)), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PRINT\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + "to": { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"EcxPrint\")(upright(\"SubstOperandAll\")(a, x_0), upright(\"SubstOperandAll\")(b, x_0))", + "colored_source": "upright(\"EcxPrint\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"SubstExprAll\")((upright(\"PRINT\")(a, b)), x_0) \\ upright(\"PRINT\")(a, b), upright(\"SubstExprAll\")((upright(\"PRINT\")(a, b)), x_0) arrow.r.double upright(\"EcxPrint\")(upright(\"SubstOperandAll\")(a, x_0), upright(\"SubstOperandAll\")(b, x_0))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PRINT\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PRINT\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstExprAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PRINT\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] arrow.r.double upright(\"EcxPrint\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7108_5_MyTxEggccExtraction_add_rule__r0101__c80ffccff7e87519", + "display_name": "r0101", + "rule_name": "r0101", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 218435, + "line": 7108, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 218435, + "end": 218661 + }, + "pattern_range": { + "start": 218481, + "end": 218492 + }, + "action_range": { + "start": 218494, + "end": 218660 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "f: EcxOperand", + "range": { + "start": 88662, + "end": 88695 + }, + "inputs": [] + }, + { + "id": "ops", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "ops: EcxVecOperandBase", + "range": { + "start": 88700, + "end": 88742 + }, + "inputs": [] + }, + { + "id": "x", + "kind": "query", + "dsl_type": "", + "label": "x: ", + "range": { + "start": 88747, + "end": 88792 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxArg", + "label": "_t2: EcxArg", + "range": { + "start": 88797, + "end": 88823 + }, + "inputs": [] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t3: EcxVO", + "range": { + "start": 88828, + "end": 88857 + }, + "inputs": [ + "ops" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstOperandAll", + "label": "_t1: EcxSubstOperandAll", + "range": { + "start": 88862, + "end": 88910 + }, + "inputs": [ + "_t2", + "_t3" + ] + }, + { + "id": "_t5", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t5: EcxVO", + "range": { + "start": 88915, + "end": 88944 + }, + "inputs": [ + "ops" + ] + }, + { + "id": "_f4", + "kind": "query", + "dsl_type": "EcxVecOperand_length", + "label": "_f4: EcxVecOperand_length", + "range": { + "start": 88949, + "end": 88993 + }, + "inputs": [ + "_t5" + ] + } + ], + "edges": [ + { + "from": "_t3", + "to": "ops", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t3", + "kind": "operand", + "index": 1 + }, + { + "from": "_t5", + "to": "ops", + "kind": "operand", + "index": 0 + }, + { + "from": "_f4", + "to": "_t5", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "f", + "ops", + "x", + "_t1", + "_t2", + "_t3", + "_f4", + "_t5" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x.handle().eq(&_t2.handle_a0())", + "semantic_text": "x == _t2.a0", + "referenced_vars": [ + "_t2", + "x" + ], + "range": { + "start": 89195, + "end": 89197 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 89215, + "end": 89217 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "x.handle().lt(&_f4.handle())", + "semantic_text": "x < _f4", + "referenced_vars": [ + "_f4", + "x" + ], + "range": { + "start": 89235, + "end": 89237 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@218524:218550", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_vo(pat.ops)", + "semantic_text": null, + "referenced_pat_vars": [ + "ops" + ], + "referenced_action_vars": [], + "range": { + "start": 218524, + "end": 218550 + } + }, + { + "id": "effect_1", + "effect_id": "effect@218569:218623", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_vec_operand_get(t2, ctx.devalue(pat.x))", + "semantic_text": null, + "referenced_pat_vars": [ + "x" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 218569, + "end": 218623 + } + }, + { + "id": "effect_2", + "effect_id": "effect@218633:218653", + "bound_var": null, + "source_text": "ctx.union(pat.f, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "f" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 218633, + "end": 218653 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0101", + "premises": [ + { + "target_id": "x", + "label": "x: ", + "plain_source": "x", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstOperandAll", + "plain_source": "upright(\"SubstOperandAll\")(upright(\"_t2\"), upright(\"_t3\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxArg", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"ops\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $]) $]" + }, + { + "target_id": "_f4", + "label": "_f4: EcxVecOperand_length", + "plain_source": "upright(\"EcxVecOperand_length\")(upright(\"VO\")(upright(\"ops\")))", + "colored_source": "upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $]) $])" + }, + { + "target_id": "_t5", + "label": "_t5: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"ops\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $]) $]" + } + ], + "side_conditions": [ + "x == upright(\"_t2.a0\")", + "f == upright(\"_t1\")", + "x < upright(\"_f4\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"EcxVo\")(upright(\"ops\"))", + "colored_source": "upright(\"EcxVo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $])" + }, + { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"EcxVecOperandGet\")(upright(\"EcxVo\")(upright(\"ops\")), x)", + "colored_source": "upright(\"EcxVecOperandGet\")(upright(\"EcxVo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $]), #text(fill: rgb(\"#5F7A8A\"))[$ x $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "f", + "label": "f: EcxOperand", + "plain_source": "f", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ f $]" + }, + "to": { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"EcxVecOperandGet\")(upright(\"EcxVo\")(upright(\"ops\")), x)", + "colored_source": "upright(\"EcxVecOperandGet\")(upright(\"EcxVo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $]), #text(fill: rgb(\"#5F7A8A\"))[$ x $])" + } + } + ], + "formula_source": { + "plain": "frac(x \\ upright(\"SubstOperandAll\")(upright(\"_t2\"), upright(\"_t3\")) \\ upright(\"_t2\") \\ upright(\"VO\")(upright(\"ops\")) \\ upright(\"EcxVecOperand_length\")(upright(\"VO\")(upright(\"ops\"))) \\ upright(\"VO\")(upright(\"ops\")), f arrow.r.double upright(\"EcxVecOperandGet\")(upright(\"EcxVo\")(upright(\"ops\")), x)) quad upright(\"if\") quad x == upright(\"_t2.a0\") \\ f == upright(\"_t1\") \\ x < upright(\"_f4\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $]) $] \\ upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ f $] arrow.r.double upright(\"EcxVecOperandGet\")(upright(\"EcxVo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $]), #text(fill: rgb(\"#5F7A8A\"))[$ x $])) quad upright(\"if\") quad x == upright(\"_t2.a0\") \\ f == upright(\"_t1\") \\ x < upright(\"_f4\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7113_5_MyTxEggccExtraction_add_rule__r0102__c0352bdd39864804", + "display_name": "r0102", + "rule_name": "r0102", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 218667, + "line": 7113, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 218667, + "end": 218882 + }, + "pattern_range": { + "start": 218713, + "end": 218724 + }, + "action_range": { + "start": 218726, + "end": 218881 + } + }, + "nodes": [ + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "b: EcxBody", + "range": { + "start": 89438, + "end": 89468 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "x0: EcxVecOperand", + "range": { + "start": 89473, + "end": 89510 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t2: EcxNode", + "range": { + "start": 89515, + "end": 89544 + }, + "inputs": [ + "b" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstOperandAll", + "label": "_t1: EcxSubstOperandAll", + "range": { + "start": 89549, + "end": 89596 + }, + "inputs": [ + "_t2", + "x0" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "b", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "b", + "x0", + "_t1", + "_t2" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@218756:218800", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_body_all(pat.b, pat.x0)", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "x0" + ], + "referenced_action_vars": [], + "range": { + "start": 218756, + "end": 218800 + } + }, + { + "id": "effect_1", + "effect_id": "effect@218819:218842", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_node(t2)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 218819, + "end": 218842 + } + }, + { + "id": "effect_2", + "effect_id": "effect@218852:218874", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 218852, + "end": 218874 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0102", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxSubstOperandAll", + "plain_source": "upright(\"SubstOperandAll\")((upright(\"Node\")(b)), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstOperandAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxNode", + "plain_source": "upright(\"Node\")(b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"SubstBodyAll\")(b, x_0)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstBodyAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"Node\")((upright(\"SubstBodyAll\")(b, x_0)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Node\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstBodyAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstOperandAll", + "plain_source": "upright(\"SubstOperandAll\")((upright(\"Node\")(b)), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstOperandAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + "to": { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"Node\")((upright(\"SubstBodyAll\")(b, x_0)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Node\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstBodyAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"SubstOperandAll\")((upright(\"Node\")(b)), x_0) \\ upright(\"Node\")(b), upright(\"SubstOperandAll\")((upright(\"Node\")(b)), x_0) arrow.r.double upright(\"Node\")((upright(\"SubstBodyAll\")(b, x_0)))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstOperandAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstOperandAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Node\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstBodyAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $])) $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7118_5_MyTxEggccExtraction_add_rule__r0103__0ac8756a57a43a36", + "display_name": "r0103", + "rule_name": "r0103", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 218888, + "line": 7118, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 218888, + "end": 219126 + }, + "pattern_range": { + "start": 218934, + "end": 218945 + }, + "action_range": { + "start": 218947, + "end": 219125 + } + }, + "nodes": [ + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "b: EcxBody", + "range": { + "start": 89845, + "end": 89875 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 89880, + "end": 89925 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "x0: EcxVecOperand", + "range": { + "start": 89930, + "end": 89967 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxProject", + "label": "_t2: EcxProject", + "range": { + "start": 89972, + "end": 90004 + }, + "inputs": [ + "b" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstOperandAll", + "label": "_t1: EcxSubstOperandAll", + "range": { + "start": 90009, + "end": 90056 + }, + "inputs": [ + "_t2", + "x0" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "b", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "b", + "i", + "x0", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_t2.handle_a0())", + "semantic_text": "i == _t2.a0", + "referenced_vars": [ + "_t2", + "i" + ], + "range": { + "start": 90147, + "end": 90149 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@218977:219021", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_body_all(pat.b, pat.x0)", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "x0" + ], + "referenced_action_vars": [], + "range": { + "start": 218977, + "end": 219021 + } + }, + { + "id": "effect_1", + "effect_id": "effect@219040:219086", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_project(ctx.devalue(pat.i), t2)", + "semantic_text": null, + "referenced_pat_vars": [ + "i" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 219040, + "end": 219086 + } + }, + { + "id": "effect_2", + "effect_id": "effect@219096:219118", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 219096, + "end": 219118 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0103", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstOperandAll", + "plain_source": "upright(\"SubstOperandAll\")(upright(\"_t2\"), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxProject", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + } + ], + "side_conditions": [ + "i == upright(\"_t2.a0\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"SubstBodyAll\")(b, x_0)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstBodyAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"Project\")(i, (upright(\"SubstBodyAll\")(b, x_0)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Project\")(#text(fill: rgb(\"#5F7A8A\"))[$ i $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstBodyAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstOperandAll", + "plain_source": "upright(\"SubstOperandAll\")(upright(\"_t2\"), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + "to": { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"Project\")(i, (upright(\"SubstBodyAll\")(b, x_0)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Project\")(#text(fill: rgb(\"#5F7A8A\"))[$ i $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstBodyAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(i \\ upright(\"SubstOperandAll\")(upright(\"_t2\"), x_0) \\ upright(\"_t2\"), upright(\"SubstOperandAll\")(upright(\"_t2\"), x_0) arrow.r.double upright(\"Project\")(i, (upright(\"SubstBodyAll\")(b, x_0)))) quad upright(\"if\") quad i == upright(\"_t2.a0\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Project\")(#text(fill: rgb(\"#5F7A8A\"))[$ i $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstBodyAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $])) $]) quad upright(\"if\") quad i == upright(\"_t2.a0\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7123_5_MyTxEggccExtraction_add_rule__r0104__dc0fa6b1c3332e21", + "display_name": "r0104", + "rule_name": "r0104", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 219132, + "line": 7123, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 219132, + "end": 219350 + }, + "pattern_range": { + "start": 219178, + "end": 219189 + }, + "action_range": { + "start": 219191, + "end": 219349 + } + }, + "nodes": [ + { + "id": "e", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "e: EcxExpr", + "range": { + "start": 90349, + "end": 90379 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "x0: EcxVecOperand", + "range": { + "start": 90384, + "end": 90421 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t2: EcxPureOp", + "range": { + "start": 90426, + "end": 90457 + }, + "inputs": [ + "e" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstBodyAll", + "label": "_t1: EcxSubstBodyAll", + "range": { + "start": 90462, + "end": 90506 + }, + "inputs": [ + "_t2", + "x0" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "e", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "e", + "x0", + "_t1", + "_t2" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@219221:219265", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_expr_all(pat.e, pat.x0)", + "semantic_text": null, + "referenced_pat_vars": [ + "e", + "x0" + ], + "referenced_action_vars": [], + "range": { + "start": 219221, + "end": 219265 + } + }, + { + "id": "effect_1", + "effect_id": "effect@219284:219310", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_pure_op(t2)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 219284, + "end": 219310 + } + }, + { + "id": "effect_2", + "effect_id": "effect@219320:219342", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 219320, + "end": 219342 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0104", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxSubstBodyAll", + "plain_source": "upright(\"SubstBodyAll\")((upright(\"PureOp\")(e)), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstBodyAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxPureOp", + "plain_source": "upright(\"PureOp\")(e)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $]) $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"SubstExprAll\")(e, x_0)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstExprAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"PureOp\")((upright(\"SubstExprAll\")(e, x_0)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstExprAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstBodyAll", + "plain_source": "upright(\"SubstBodyAll\")((upright(\"PureOp\")(e)), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstBodyAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + "to": { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"PureOp\")((upright(\"SubstExprAll\")(e, x_0)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstExprAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"SubstBodyAll\")((upright(\"PureOp\")(e)), x_0) \\ upright(\"PureOp\")(e), upright(\"SubstBodyAll\")((upright(\"PureOp\")(e)), x_0) arrow.r.double upright(\"PureOp\")((upright(\"SubstExprAll\")(e, x_0)))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstBodyAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstBodyAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstExprAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $])) $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7128_5_MyTxEggccExtraction_add_rule__r0105__d75054abbed8ab07", + "display_name": "r0105", + "rule_name": "r0105", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 219356, + "line": 7128, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 219356, + "end": 219670 + }, + "pattern_range": { + "start": 219402, + "end": 219413 + }, + "action_range": { + "start": 219415, + "end": 219669 + } + }, + "nodes": [ + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 90802, + "end": 90843 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "outputs: EcxVecVecOperand", + "range": { + "start": 90848, + "end": 90893 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 90898, + "end": 90934 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "x0: EcxVecOperand", + "range": { + "start": 90939, + "end": 90976 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxGamma", + "label": "_t2: EcxGamma", + "range": { + "start": 90981, + "end": 91033 + }, + "inputs": [ + "pred", + "inputs", + "outputs" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstBodyAll", + "label": "_t1: EcxSubstBodyAll", + "range": { + "start": 91038, + "end": 91082 + }, + "inputs": [ + "_t2", + "x0" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "outputs", + "kind": "operand", + "index": 2 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "inputs", + "outputs", + "pred", + "x0", + "_t1", + "_t2" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@219445:219495", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_operand_all(pat.pred, pat.x0)", + "semantic_text": null, + "referenced_pat_vars": [ + "pred", + "x0" + ], + "referenced_action_vars": [], + "range": { + "start": 219445, + "end": 219495 + } + }, + { + "id": "effect_1", + "effect_id": "effect@219514:219570", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_subst_vec_operand_all(pat.inputs, pat.x0)", + "semantic_text": null, + "referenced_pat_vars": [ + "inputs", + "x0" + ], + "referenced_action_vars": [], + "range": { + "start": 219514, + "end": 219570 + } + }, + { + "id": "effect_2", + "effect_id": "effect@219589:219630", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_gamma(t2, t3, pat.outputs)", + "semantic_text": null, + "referenced_pat_vars": [ + "outputs" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 219589, + "end": 219630 + } + }, + { + "id": "effect_3", + "effect_id": "effect@219640:219662", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 219640, + "end": 219662 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0105", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxSubstBodyAll", + "plain_source": "upright(\"SubstBodyAll\")((upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstBodyAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxGamma", + "plain_source": "upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"SubstOperandAll\")(upright(\"pred\"), x_0)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"SubstVecOperandAll\")(upright(\"inputs\"), x_0)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"Gamma\")((upright(\"SubstOperandAll\")(upright(\"pred\"), x_0)), (upright(\"SubstVecOperandAll\")(upright(\"inputs\"), x_0)), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_3", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstBodyAll", + "plain_source": "upright(\"SubstBodyAll\")((upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstBodyAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + "to": { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"Gamma\")((upright(\"SubstOperandAll\")(upright(\"pred\"), x_0)), (upright(\"SubstVecOperandAll\")(upright(\"inputs\"), x_0)), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"SubstBodyAll\")((upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))), x_0) \\ upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\")), upright(\"SubstBodyAll\")((upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))), x_0) arrow.r.double upright(\"Gamma\")((upright(\"SubstOperandAll\")(upright(\"pred\"), x_0)), (upright(\"SubstVecOperandAll\")(upright(\"inputs\"), x_0)), upright(\"outputs\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstBodyAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstBodyAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7134_5_MyTxEggccExtraction_add_rule__r0106__8e4f629bb4225aef", + "display_name": "r0106", + "rule_name": "r0106", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 219676, + "line": 7134, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 219676, + "end": 219927 + }, + "pattern_range": { + "start": 219722, + "end": 219733 + }, + "action_range": { + "start": 219735, + "end": 219926 + } + }, + "nodes": [ + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 91395, + "end": 91436 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "outputs: EcxVecOperand", + "range": { + "start": 91441, + "end": 91483 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 91488, + "end": 91524 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "x0: EcxVecOperand", + "range": { + "start": 91529, + "end": 91566 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxTheta", + "label": "_t2: EcxTheta", + "range": { + "start": 91571, + "end": 91623 + }, + "inputs": [ + "pred", + "inputs", + "outputs" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstBodyAll", + "label": "_t1: EcxSubstBodyAll", + "range": { + "start": 91628, + "end": 91672 + }, + "inputs": [ + "_t2", + "x0" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "outputs", + "kind": "operand", + "index": 2 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "inputs", + "outputs", + "pred", + "x0", + "_t1", + "_t2" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@219765:219821", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_vec_operand_all(pat.inputs, pat.x0)", + "semantic_text": null, + "referenced_pat_vars": [ + "inputs", + "x0" + ], + "referenced_action_vars": [], + "range": { + "start": 219765, + "end": 219821 + } + }, + { + "id": "effect_1", + "effect_id": "effect@219840:219887", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_theta(pat.pred, t2, pat.outputs)", + "semantic_text": null, + "referenced_pat_vars": [ + "outputs", + "pred" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 219840, + "end": 219887 + } + }, + { + "id": "effect_2", + "effect_id": "effect@219897:219919", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 219897, + "end": 219919 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0106", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxSubstBodyAll", + "plain_source": "upright(\"SubstBodyAll\")((upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstBodyAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxTheta", + "plain_source": "upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"SubstVecOperandAll\")(upright(\"inputs\"), x_0)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"Theta\")(upright(\"pred\"), (upright(\"SubstVecOperandAll\")(upright(\"inputs\"), x_0)), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstBodyAll", + "plain_source": "upright(\"SubstBodyAll\")((upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstBodyAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + "to": { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"Theta\")(upright(\"pred\"), (upright(\"SubstVecOperandAll\")(upright(\"inputs\"), x_0)), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"SubstBodyAll\")((upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))), x_0) \\ upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\")), upright(\"SubstBodyAll\")((upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))), x_0) arrow.r.double upright(\"Theta\")(upright(\"pred\"), (upright(\"SubstVecOperandAll\")(upright(\"inputs\"), x_0)), upright(\"outputs\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstBodyAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstBodyAll\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7139_5_MyTxEggccExtraction_add_rule__r0107__829e8e4a9046a7cb", + "display_name": "r0107", + "rule_name": "r0107", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 219933, + "line": 7139, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 219933, + "end": 220129 + }, + "pattern_range": { + "start": 219979, + "end": 219990 + }, + "action_range": { + "start": 219992, + "end": 220128 + } + }, + "nodes": [ + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "vec: EcxVecOperand", + "range": { + "start": 91919, + "end": 91957 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "x0: EcxVecOperand", + "range": { + "start": 91962, + "end": 91999 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstVecOperandAll", + "label": "_t1: EcxSubstVecOperandAll", + "range": { + "start": 92004, + "end": 92054 + }, + "inputs": [ + "vec", + "x0" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "vec", + "x0", + "_t1" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@220022:220089", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_subst_vec_operand_all_helper(pat.vec, pat.x0, 0_i64)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec", + "x0" + ], + "referenced_action_vars": [], + "range": { + "start": 220022, + "end": 220089 + } + }, + { + "id": "effect_1", + "effect_id": "effect@220099:220121", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 220099, + "end": 220121 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0107", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxSubstVecOperandAll", + "plain_source": "upright(\"SubstVecOperandAll\")(upright(\"vec\"), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstVecOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"EcxSubstVecOperandAllHelper\")(upright(\"vec\"), x_0, 0)", + "colored_source": "upright(\"EcxSubstVecOperandAllHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#B86A5B\"))[$ 0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstVecOperandAll", + "plain_source": "upright(\"SubstVecOperandAll\")(upright(\"vec\"), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstVecOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"EcxSubstVecOperandAllHelper\")(upright(\"vec\"), x_0, 0)", + "colored_source": "upright(\"EcxSubstVecOperandAllHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#B86A5B\"))[$ 0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"SubstVecOperandAll\")(upright(\"vec\"), x_0), upright(\"SubstVecOperandAll\")(upright(\"vec\"), x_0) arrow.r.double upright(\"EcxSubstVecOperandAllHelper\")(upright(\"vec\"), x_0, 0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstVecOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstVecOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] arrow.r.double upright(\"EcxSubstVecOperandAllHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#B86A5B\"))[$ 0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7143_5_MyTxEggccExtraction_add_rule__r0108__c026f8398a7badfb", + "display_name": "r0108", + "rule_name": "r0108", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 220135, + "line": 7143, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 220135, + "end": 220977 + }, + "pattern_range": { + "start": 220181, + "end": 220192 + }, + "action_range": { + "start": 220194, + "end": 220976 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "f: EcxVecOperand", + "range": { + "start": 92369, + "end": 92405 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 92410, + "end": 92455 + }, + "inputs": [] + }, + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "vec: EcxVecOperandBase", + "range": { + "start": 92460, + "end": 92502 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "x0: EcxVecOperand", + "range": { + "start": 92507, + "end": 92544 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t2: EcxVO", + "range": { + "start": 92549, + "end": 92578 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstVecOperandAll_helper", + "label": "_t1: EcxSubstVecOperandAll_helper", + "range": { + "start": 92583, + "end": 92640 + }, + "inputs": [ + "_t2", + "x0" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t4: EcxVO", + "range": { + "start": 92645, + "end": 92674 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxVecOperand_length", + "label": "_f3: EcxVecOperand_length", + "range": { + "start": 92679, + "end": 92723 + }, + "inputs": [ + "_t4" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x0", + "kind": "operand", + "index": 1 + }, + { + "from": "_t4", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "_t4", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "f", + "i", + "vec", + "x0", + "_t1", + "_t2", + "_f3", + "_t4" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_t1.handle_a2())", + "semantic_text": "i == _t1.a2", + "referenced_vars": [ + "_t1", + "i" + ], + "range": { + "start": 92924, + "end": 92926 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 92944, + "end": 92946 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "i.handle().lt(&_f3.handle())", + "semantic_text": "i < _f3", + "referenced_vars": [ + "_f3", + "i" + ], + "range": { + "start": 92964, + "end": 92966 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@220224:220250", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_vo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 220224, + "end": 220250 + } + }, + { + "id": "effect_1", + "effect_id": "effect@220269:220344", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_subst_vec_operand_all_helper(t2, pat.x0, ctx.devalue(pat.i))", + "semantic_text": null, + "referenced_pat_vars": [ + "i", + "x0" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 220269, + "end": 220344 + } + }, + { + "id": "effect_2", + "effect_id": "effect@220363:220389", + "bound_var": "t7", + "source_text": "ctx.insert_ecx_vo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 220363, + "end": 220389 + } + }, + { + "id": "effect_3", + "effect_id": "effect@220408:220462", + "bound_var": "t6", + "source_text": "ctx.insert_ecx_vec_operand_get(t7, ctx.devalue(pat.i))", + "semantic_text": null, + "referenced_pat_vars": [ + "i" + ], + "referenced_action_vars": [ + "t7" + ], + "range": { + "start": 220408, + "end": 220462 + } + }, + { + "id": "effect_4", + "effect_id": "effect@220481:220525", + "bound_var": "t5", + "source_text": "ctx.insert_ecx_subst_operand_all(t6, pat.x0)", + "semantic_text": null, + "referenced_pat_vars": [ + "x0" + ], + "referenced_action_vars": [ + "t6" + ], + "range": { + "start": 220481, + "end": 220525 + } + }, + { + "id": "effect_5", + "effect_id": "effect@220544:220826", + "bound_var": "t4", + "source_text": "ctx.insert_ecx_vo(\n ctx.intern_container::>(vec_set::<\n EcxOperand,\n >(\n &*ctx.devalue(pat.vec),\n ctx.devalue(pat.i),\n t5.erase(),\n )),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "i", + "vec" + ], + "referenced_action_vars": [ + "t5" + ], + "range": { + "start": 220544, + "end": 220826 + } + }, + { + "id": "effect_6", + "effect_id": "effect@220857:220942", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_subst_vec_operand_all_helper(t4, pat.x0, (ctx.devalue(pat.i) + 1_i64))", + "semantic_text": null, + "referenced_pat_vars": [ + "i", + "x0" + ], + "referenced_action_vars": [ + "t4" + ], + "range": { + "start": 220857, + "end": 220942 + } + }, + { + "id": "effect_7", + "effect_id": "effect@220952:220969", + "bound_var": null, + "source_text": "ctx.union(t1, t3)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t1", + "t3" + ], + "range": { + "start": 220952, + "end": 220969 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0108", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstVecOperandAll_helper", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxVecOperand_length", + "plain_source": "upright(\"EcxVecOperand_length\")(upright(\"VO\")(upright(\"vec\")))", + "colored_source": "upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + } + ], + "side_conditions": [ + "i == upright(\"_t1.a2\")", + "f == upright(\"_t1\")", + "i < upright(\"_f3\")" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(i \\ upright(\"_t1\") \\ upright(\"VO\")(upright(\"vec\")) \\ upright(\"EcxVecOperand_length\")(upright(\"VO\")(upright(\"vec\"))) \\ upright(\"VO\")(upright(\"vec\")), upright(\"no conclusion\")) quad upright(\"if\") quad i == upright(\"_t1.a2\") \\ f == upright(\"_t1\") \\ i < upright(\"_f3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $] \\ upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], upright(\"no conclusion\")) quad upright(\"if\") quad i == upright(\"_t1.a2\") \\ f == upright(\"_t1\") \\ i < upright(\"_f3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7162_5_MyTxEggccExtraction_add_rule__r0109__9458bdb46911de51", + "display_name": "r0109", + "rule_name": "r0109", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 220983, + "line": 7162, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 220983, + "end": 221272 + }, + "pattern_range": { + "start": 221029, + "end": 221040 + }, + "action_range": { + "start": 221042, + "end": 221271 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "f: EcxVecOperand", + "range": { + "start": 93251, + "end": 93287 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 93292, + "end": 93337 + }, + "inputs": [] + }, + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "vec: EcxVecOperandBase", + "range": { + "start": 93342, + "end": 93384 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "x0: EcxVecOperand", + "range": { + "start": 93389, + "end": 93426 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t2: EcxVO", + "range": { + "start": 93431, + "end": 93460 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstVecOperandAll_helper", + "label": "_t1: EcxSubstVecOperandAll_helper", + "range": { + "start": 93465, + "end": 93522 + }, + "inputs": [ + "_t2", + "x0" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t4: EcxVO", + "range": { + "start": 93527, + "end": 93556 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxVecOperand_length", + "label": "_f3: EcxVecOperand_length", + "range": { + "start": 93561, + "end": 93605 + }, + "inputs": [ + "_t4" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x0", + "kind": "operand", + "index": 1 + }, + { + "from": "_t4", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "_t4", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "f", + "i", + "vec", + "x0", + "_t1", + "_t2", + "_f3", + "_t4" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_t1.handle_a2())", + "semantic_text": "i == _t1.a2", + "referenced_vars": [ + "_t1", + "i" + ], + "range": { + "start": 93806, + "end": 93808 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 93826, + "end": 93828 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "i.handle().eq(&_f3.handle())", + "semantic_text": "i == _f3", + "referenced_vars": [ + "_f3", + "i" + ], + "range": { + "start": 93846, + "end": 93848 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@221072:221098", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_vo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 221072, + "end": 221098 + } + }, + { + "id": "effect_1", + "effect_id": "effect@221117:221192", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_subst_vec_operand_all_helper(t2, pat.x0, ctx.devalue(pat.i))", + "semantic_text": null, + "referenced_pat_vars": [ + "i", + "x0" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 221117, + "end": 221192 + } + }, + { + "id": "effect_2", + "effect_id": "effect@221211:221237", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_vo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 221211, + "end": 221237 + } + }, + { + "id": "effect_3", + "effect_id": "effect@221247:221264", + "bound_var": null, + "source_text": "ctx.union(t1, t3)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t1", + "t3" + ], + "range": { + "start": 221247, + "end": 221264 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0109", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstVecOperandAll_helper", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxVecOperand_length", + "plain_source": "upright(\"EcxVecOperand_length\")(upright(\"VO\")(upright(\"vec\")))", + "colored_source": "upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + } + ], + "side_conditions": [ + "i == upright(\"_t1.a2\")", + "f == upright(\"_t1\")", + "i == upright(\"_f3\")" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(i \\ upright(\"_t1\") \\ upright(\"VO\")(upright(\"vec\")) \\ upright(\"EcxVecOperand_length\")(upright(\"VO\")(upright(\"vec\"))) \\ upright(\"VO\")(upright(\"vec\")), upright(\"no conclusion\")) quad upright(\"if\") quad i == upright(\"_t1.a2\") \\ f == upright(\"_t1\") \\ i == upright(\"_f3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $] \\ upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], upright(\"no conclusion\")) quad upright(\"if\") quad i == upright(\"_t1.a2\") \\ f == upright(\"_t1\") \\ i == upright(\"_f3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7168_5_MyTxEggccExtraction_add_rule__r0110__bb9ce155acb5add5", + "display_name": "r0110", + "rule_name": "r0110", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 221278, + "line": 7168, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 221278, + "end": 221478 + }, + "pattern_range": { + "start": 221324, + "end": 221335 + }, + "action_range": { + "start": 221337, + "end": 221477 + } + }, + "nodes": [ + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "vec: EcxVecVecOperand", + "range": { + "start": 94048, + "end": 94089 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "x0: EcxVecOperand", + "range": { + "start": 94094, + "end": 94131 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstVecVecOperandAll", + "label": "_t1: EcxSubstVecVecOperandAll", + "range": { + "start": 94136, + "end": 94189 + }, + "inputs": [ + "vec", + "x0" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x0", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "vec", + "x0", + "_t1" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@221367:221438", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_subst_vec_vec_operand_all_helper(pat.vec, pat.x0, 0_i64)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec", + "x0" + ], + "referenced_action_vars": [], + "range": { + "start": 221367, + "end": 221438 + } + }, + { + "id": "effect_1", + "effect_id": "effect@221448:221470", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 221448, + "end": 221470 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0110", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxSubstVecVecOperandAll", + "plain_source": "upright(\"SubstVecVecOperandAll\")(upright(\"vec\"), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstVecVecOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"EcxSubstVecVecOperandAllHelper\")(upright(\"vec\"), x_0, 0)", + "colored_source": "upright(\"EcxSubstVecVecOperandAllHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#B86A5B\"))[$ 0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "_t1", + "label": "_t1: EcxSubstVecVecOperandAll", + "plain_source": "upright(\"SubstVecVecOperandAll\")(upright(\"vec\"), x_0)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstVecVecOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"EcxSubstVecVecOperandAllHelper\")(upright(\"vec\"), x_0, 0)", + "colored_source": "upright(\"EcxSubstVecVecOperandAllHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#B86A5B\"))[$ 0 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"SubstVecVecOperandAll\")(upright(\"vec\"), x_0), upright(\"SubstVecVecOperandAll\")(upright(\"vec\"), x_0) arrow.r.double upright(\"EcxSubstVecVecOperandAllHelper\")(upright(\"vec\"), x_0, 0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstVecVecOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"SubstVecVecOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]) $] arrow.r.double upright(\"EcxSubstVecVecOperandAllHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#B86A5B\"))[$ 0 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7172_5_MyTxEggccExtraction_add_rule__r0111__cdabeb956f7ff081", + "display_name": "r0111", + "rule_name": "r0111", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 221484, + "line": 7172, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 221484, + "end": 222389 + }, + "pattern_range": { + "start": 221530, + "end": 221541 + }, + "action_range": { + "start": 221543, + "end": 222388 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "f: EcxVecVecOperand", + "range": { + "start": 94515, + "end": 94554 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 94559, + "end": 94604 + }, + "inputs": [] + }, + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperandBase", + "label": "vec: EcxVecVecOperandBase", + "range": { + "start": 94609, + "end": 94654 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "x0: EcxVecOperand", + "range": { + "start": 94659, + "end": 94696 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t2: EcxVVO", + "range": { + "start": 94701, + "end": 94731 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstVecVecOperandAll_helper", + "label": "_t1: EcxSubstVecVecOperandAll_helper", + "range": { + "start": 94736, + "end": 94796 + }, + "inputs": [ + "_t2", + "x0" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t4: EcxVVO", + "range": { + "start": 94801, + "end": 94831 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxVecVecOperand_length", + "label": "_f3: EcxVecVecOperand_length", + "range": { + "start": 94836, + "end": 94883 + }, + "inputs": [ + "_t4" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x0", + "kind": "operand", + "index": 1 + }, + { + "from": "_t4", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "_t4", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "f", + "i", + "vec", + "x0", + "_t1", + "_t2", + "_f3", + "_t4" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_t1.handle_a2())", + "semantic_text": "i == _t1.a2", + "referenced_vars": [ + "_t1", + "i" + ], + "range": { + "start": 95084, + "end": 95086 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 95104, + "end": 95106 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "i.handle().lt(&_f3.handle())", + "semantic_text": "i < _f3", + "referenced_vars": [ + "_f3", + "i" + ], + "range": { + "start": 95124, + "end": 95126 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@221573:221600", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_vvo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 221573, + "end": 221600 + } + }, + { + "id": "effect_1", + "effect_id": "effect@221619:221698", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_subst_vec_vec_operand_all_helper(t2, pat.x0, ctx.devalue(pat.i))", + "semantic_text": null, + "referenced_pat_vars": [ + "i", + "x0" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 221619, + "end": 221698 + } + }, + { + "id": "effect_2", + "effect_id": "effect@221717:221744", + "bound_var": "t7", + "source_text": "ctx.insert_ecx_vvo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 221717, + "end": 221744 + } + }, + { + "id": "effect_3", + "effect_id": "effect@221763:221821", + "bound_var": "t6", + "source_text": "ctx.insert_ecx_vec_vec_operand_get(t7, ctx.devalue(pat.i))", + "semantic_text": null, + "referenced_pat_vars": [ + "i" + ], + "referenced_action_vars": [ + "t7" + ], + "range": { + "start": 221763, + "end": 221821 + } + }, + { + "id": "effect_4", + "effect_id": "effect@221840:221888", + "bound_var": "t5", + "source_text": "ctx.insert_ecx_subst_vec_operand_all(t6, pat.x0)", + "semantic_text": null, + "referenced_pat_vars": [ + "x0" + ], + "referenced_action_vars": [ + "t6" + ], + "range": { + "start": 221840, + "end": 221888 + } + }, + { + "id": "effect_5", + "effect_id": "effect@221907:222199", + "bound_var": "t4", + "source_text": "ctx.insert_ecx_vvo(\n ctx.intern_container::>(vec_set::<\n EcxVecOperand,\n >(\n &*ctx.devalue(pat.vec),\n ctx.devalue(pat.i),\n t5.erase(),\n )),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "i", + "vec" + ], + "referenced_action_vars": [ + "t5" + ], + "range": { + "start": 221907, + "end": 222199 + } + }, + { + "id": "effect_6", + "effect_id": "effect@222218:222354", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_subst_vec_vec_operand_all_helper(\n t4,\n pat.x0,\n (ctx.devalue(pat.i) + 1_i64),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "i", + "x0" + ], + "referenced_action_vars": [ + "t4" + ], + "range": { + "start": 222218, + "end": 222354 + } + }, + { + "id": "effect_7", + "effect_id": "effect@222364:222381", + "bound_var": null, + "source_text": "ctx.union(t1, t3)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t1", + "t3" + ], + "range": { + "start": 222364, + "end": 222381 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0111", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstVecVecOperandAll_helper", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxVecVecOperand_length", + "plain_source": "upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(upright(\"vec\")))", + "colored_source": "upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + } + ], + "side_conditions": [ + "i == upright(\"_t1.a2\")", + "f == upright(\"_t1\")", + "i < upright(\"_f3\")" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(i \\ upright(\"_t1\") \\ upright(\"VVO\")(upright(\"vec\")) \\ upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(upright(\"vec\"))) \\ upright(\"VVO\")(upright(\"vec\")), upright(\"no conclusion\")) quad upright(\"if\") quad i == upright(\"_t1.a2\") \\ f == upright(\"_t1\") \\ i < upright(\"_f3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $] \\ upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], upright(\"no conclusion\")) quad upright(\"if\") quad i == upright(\"_t1.a2\") \\ f == upright(\"_t1\") \\ i < upright(\"_f3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7194_5_MyTxEggccExtraction_add_rule__r0112__d02871ddce74bff0", + "display_name": "r0112", + "rule_name": "r0112", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 222395, + "line": 7194, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 222395, + "end": 222690 + }, + "pattern_range": { + "start": 222441, + "end": 222452 + }, + "action_range": { + "start": 222454, + "end": 222689 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "f: EcxVecVecOperand", + "range": { + "start": 95422, + "end": 95461 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 95466, + "end": 95511 + }, + "inputs": [] + }, + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperandBase", + "label": "vec: EcxVecVecOperandBase", + "range": { + "start": 95516, + "end": 95561 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "x0: EcxVecOperand", + "range": { + "start": 95566, + "end": 95603 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t2: EcxVVO", + "range": { + "start": 95608, + "end": 95638 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSubstVecVecOperandAll_helper", + "label": "_t1: EcxSubstVecVecOperandAll_helper", + "range": { + "start": 95643, + "end": 95703 + }, + "inputs": [ + "_t2", + "x0" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t4: EcxVVO", + "range": { + "start": 95708, + "end": 95738 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxVecVecOperand_length", + "label": "_f3: EcxVecVecOperand_length", + "range": { + "start": 95743, + "end": 95790 + }, + "inputs": [ + "_t4" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "x0", + "kind": "operand", + "index": 1 + }, + { + "from": "_t4", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "_t4", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "f", + "i", + "vec", + "x0", + "_t1", + "_t2", + "_f3", + "_t4" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_t1.handle_a2())", + "semantic_text": "i == _t1.a2", + "referenced_vars": [ + "_t1", + "i" + ], + "range": { + "start": 95991, + "end": 95993 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 96011, + "end": 96013 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "i.handle().eq(&_f3.handle())", + "semantic_text": "i == _f3", + "referenced_vars": [ + "_f3", + "i" + ], + "range": { + "start": 96031, + "end": 96033 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@222484:222511", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_vvo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 222484, + "end": 222511 + } + }, + { + "id": "effect_1", + "effect_id": "effect@222530:222609", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_subst_vec_vec_operand_all_helper(t2, pat.x0, ctx.devalue(pat.i))", + "semantic_text": null, + "referenced_pat_vars": [ + "i", + "x0" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 222530, + "end": 222609 + } + }, + { + "id": "effect_2", + "effect_id": "effect@222628:222655", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_vvo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 222628, + "end": 222655 + } + }, + { + "id": "effect_3", + "effect_id": "effect@222665:222682", + "bound_var": null, + "source_text": "ctx.union(t1, t3)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t1", + "t3" + ], + "range": { + "start": 222665, + "end": 222682 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0112", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSubstVecVecOperandAll_helper", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxVecVecOperand_length", + "plain_source": "upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(upright(\"vec\")))", + "colored_source": "upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + } + ], + "side_conditions": [ + "i == upright(\"_t1.a2\")", + "f == upright(\"_t1\")", + "i == upright(\"_f3\")" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(i \\ upright(\"_t1\") \\ upright(\"VVO\")(upright(\"vec\")) \\ upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(upright(\"vec\"))) \\ upright(\"VVO\")(upright(\"vec\")), upright(\"no conclusion\")) quad upright(\"if\") quad i == upright(\"_t1.a2\") \\ f == upright(\"_t1\") \\ i == upright(\"_f3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $] \\ upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], upright(\"no conclusion\")) quad upright(\"if\") quad i == upright(\"_t1.a2\") \\ f == upright(\"_t1\") \\ i == upright(\"_f3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7200_5_MyTxEggccExtraction_add_rule__r0113__3644ae215c1de3db", + "display_name": "r0113", + "rule_name": "r0113", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 222696, + "line": 7200, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 222696, + "end": 223052 + }, + "pattern_range": { + "start": 222743, + "end": 222754 + }, + "action_range": { + "start": 222756, + "end": 223051 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 96270, + "end": 96303 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 96308, + "end": 96341 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty: EcxType", + "range": { + "start": 96346, + "end": 96377 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 96382, + "end": 96429 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query", + "dsl_type": "", + "label": "x1: ", + "range": { + "start": 96434, + "end": 96481 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxbadd", + "label": "_t2: Ecxbadd", + "range": { + "start": 96486, + "end": 96524 + }, + "inputs": [ + "ty", + "a", + "b" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxShiftExpr", + "label": "_t1: EcxShiftExpr", + "range": { + "start": 96529, + "end": 96565 + }, + "inputs": [ + "_t2" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "a", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "b", + "kind": "operand", + "index": 2 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "a", + "b", + "ty", + "x0", + "x1", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 96721, + "end": 96723 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "x1.handle().eq(&_t1.handle_a2())", + "semantic_text": "x1 == _t1.a2", + "referenced_vars": [ + "_t1", + "x1" + ], + "range": { + "start": 96741, + "end": 96743 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@222786:222863", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_shift_operand(pat.a, ctx.devalue(pat.x0), ctx.devalue(pat.x1))", + "semantic_text": null, + "referenced_pat_vars": [ + "a", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 222786, + "end": 222863 + } + }, + { + "id": "effect_1", + "effect_id": "effect@222882:222959", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_shift_operand(pat.b, ctx.devalue(pat.x0), ctx.devalue(pat.x1))", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 222882, + "end": 222959 + } + }, + { + "id": "effect_2", + "effect_id": "effect@222978:223012", + "bound_var": "t1", + "source_text": "ctx.insert_ecxbadd(pat.ty, t2, t3)", + "semantic_text": null, + "referenced_pat_vars": [ + "ty" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 222978, + "end": 223012 + } + }, + { + "id": "effect_3", + "effect_id": "effect@223022:223044", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 223022, + "end": 223044 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0113", + "premises": [ + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "x1", + "label": "x1: ", + "plain_source": "x_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxShiftExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxbadd", + "plain_source": "upright(\"badd\")(upright(\"ty\"), a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")", + "x_1 == upright(\"_t1.a2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"ShiftOperand\")(a, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"ShiftOperand\")(b, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"badd\")(upright(\"ty\"), (upright(\"ShiftOperand\")(a, x_0, x_1)), (upright(\"ShiftOperand\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_3", + "from": { + "target_id": "_t1", + "label": "_t1: EcxShiftExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"badd\")(upright(\"ty\"), (upright(\"ShiftOperand\")(a, x_0, x_1)), (upright(\"ShiftOperand\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(x_0 \\ x_1 \\ upright(\"_t1\") \\ upright(\"badd\")(upright(\"ty\"), a, b), upright(\"_t1\") arrow.r.double upright(\"badd\")(upright(\"ty\"), (upright(\"ShiftOperand\")(a, x_0, x_1)), (upright(\"ShiftOperand\")(b, x_0, x_1)))) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7206_5_MyTxEggccExtraction_add_rule__r0114__76026bca7bfbfc00", + "display_name": "r0114", + "rule_name": "r0114", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 223058, + "line": 7206, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 223058, + "end": 223414 + }, + "pattern_range": { + "start": 223105, + "end": 223116 + }, + "action_range": { + "start": 223118, + "end": 223413 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 96980, + "end": 97013 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 97018, + "end": 97051 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty: EcxType", + "range": { + "start": 97056, + "end": 97087 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 97092, + "end": 97139 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query", + "dsl_type": "", + "label": "x1: ", + "range": { + "start": 97144, + "end": 97191 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxbsub", + "label": "_t2: Ecxbsub", + "range": { + "start": 97196, + "end": 97234 + }, + "inputs": [ + "ty", + "a", + "b" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxShiftExpr", + "label": "_t1: EcxShiftExpr", + "range": { + "start": 97239, + "end": 97275 + }, + "inputs": [ + "_t2" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "a", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "b", + "kind": "operand", + "index": 2 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "a", + "b", + "ty", + "x0", + "x1", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 97431, + "end": 97433 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "x1.handle().eq(&_t1.handle_a2())", + "semantic_text": "x1 == _t1.a2", + "referenced_vars": [ + "_t1", + "x1" + ], + "range": { + "start": 97451, + "end": 97453 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@223148:223225", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_shift_operand(pat.a, ctx.devalue(pat.x0), ctx.devalue(pat.x1))", + "semantic_text": null, + "referenced_pat_vars": [ + "a", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 223148, + "end": 223225 + } + }, + { + "id": "effect_1", + "effect_id": "effect@223244:223321", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_shift_operand(pat.b, ctx.devalue(pat.x0), ctx.devalue(pat.x1))", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 223244, + "end": 223321 + } + }, + { + "id": "effect_2", + "effect_id": "effect@223340:223374", + "bound_var": "t1", + "source_text": "ctx.insert_ecxbsub(pat.ty, t2, t3)", + "semantic_text": null, + "referenced_pat_vars": [ + "ty" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 223340, + "end": 223374 + } + }, + { + "id": "effect_3", + "effect_id": "effect@223384:223406", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 223384, + "end": 223406 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0114", + "premises": [ + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "x1", + "label": "x1: ", + "plain_source": "x_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxShiftExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxbsub", + "plain_source": "upright(\"bsub\")(upright(\"ty\"), a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")", + "x_1 == upright(\"_t1.a2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"ShiftOperand\")(a, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"ShiftOperand\")(b, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"bsub\")(upright(\"ty\"), (upright(\"ShiftOperand\")(a, x_0, x_1)), (upright(\"ShiftOperand\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_3", + "from": { + "target_id": "_t1", + "label": "_t1: EcxShiftExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"bsub\")(upright(\"ty\"), (upright(\"ShiftOperand\")(a, x_0, x_1)), (upright(\"ShiftOperand\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(x_0 \\ x_1 \\ upright(\"_t1\") \\ upright(\"bsub\")(upright(\"ty\"), a, b), upright(\"_t1\") arrow.r.double upright(\"bsub\")(upright(\"ty\"), (upright(\"ShiftOperand\")(a, x_0, x_1)), (upright(\"ShiftOperand\")(b, x_0, x_1)))) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7212_5_MyTxEggccExtraction_add_rule__r0115__8eb6177f24d598aa", + "display_name": "r0115", + "rule_name": "r0115", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 223420, + "line": 7212, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 223420, + "end": 223776 + }, + "pattern_range": { + "start": 223467, + "end": 223478 + }, + "action_range": { + "start": 223480, + "end": 223775 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 97690, + "end": 97723 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 97728, + "end": 97761 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty: EcxType", + "range": { + "start": 97766, + "end": 97797 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 97802, + "end": 97849 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query", + "dsl_type": "", + "label": "x1: ", + "range": { + "start": 97854, + "end": 97901 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxbmul", + "label": "_t2: Ecxbmul", + "range": { + "start": 97906, + "end": 97944 + }, + "inputs": [ + "ty", + "a", + "b" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxShiftExpr", + "label": "_t1: EcxShiftExpr", + "range": { + "start": 97949, + "end": 97985 + }, + "inputs": [ + "_t2" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "a", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "b", + "kind": "operand", + "index": 2 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "a", + "b", + "ty", + "x0", + "x1", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 98141, + "end": 98143 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "x1.handle().eq(&_t1.handle_a2())", + "semantic_text": "x1 == _t1.a2", + "referenced_vars": [ + "_t1", + "x1" + ], + "range": { + "start": 98161, + "end": 98163 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@223510:223587", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_shift_operand(pat.a, ctx.devalue(pat.x0), ctx.devalue(pat.x1))", + "semantic_text": null, + "referenced_pat_vars": [ + "a", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 223510, + "end": 223587 + } + }, + { + "id": "effect_1", + "effect_id": "effect@223606:223683", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_shift_operand(pat.b, ctx.devalue(pat.x0), ctx.devalue(pat.x1))", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 223606, + "end": 223683 + } + }, + { + "id": "effect_2", + "effect_id": "effect@223702:223736", + "bound_var": "t1", + "source_text": "ctx.insert_ecxbmul(pat.ty, t2, t3)", + "semantic_text": null, + "referenced_pat_vars": [ + "ty" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 223702, + "end": 223736 + } + }, + { + "id": "effect_3", + "effect_id": "effect@223746:223768", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 223746, + "end": 223768 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0115", + "premises": [ + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "x1", + "label": "x1: ", + "plain_source": "x_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxShiftExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxbmul", + "plain_source": "upright(\"bmul\")(upright(\"ty\"), a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")", + "x_1 == upright(\"_t1.a2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"ShiftOperand\")(a, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"ShiftOperand\")(b, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"bmul\")(upright(\"ty\"), (upright(\"ShiftOperand\")(a, x_0, x_1)), (upright(\"ShiftOperand\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_3", + "from": { + "target_id": "_t1", + "label": "_t1: EcxShiftExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"bmul\")(upright(\"ty\"), (upright(\"ShiftOperand\")(a, x_0, x_1)), (upright(\"ShiftOperand\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(x_0 \\ x_1 \\ upright(\"_t1\") \\ upright(\"bmul\")(upright(\"ty\"), a, b), upright(\"_t1\") arrow.r.double upright(\"bmul\")(upright(\"ty\"), (upright(\"ShiftOperand\")(a, x_0, x_1)), (upright(\"ShiftOperand\")(b, x_0, x_1)))) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7218_5_MyTxEggccExtraction_add_rule__r0116__cdfc833b54d3c41d", + "display_name": "r0116", + "rule_name": "r0116", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 223782, + "line": 7218, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 223782, + "end": 224138 + }, + "pattern_range": { + "start": 223829, + "end": 223840 + }, + "action_range": { + "start": 223842, + "end": 224137 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 98400, + "end": 98433 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 98438, + "end": 98471 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty: EcxType", + "range": { + "start": 98476, + "end": 98507 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 98512, + "end": 98559 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query", + "dsl_type": "", + "label": "x1: ", + "range": { + "start": 98564, + "end": 98611 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxbdiv", + "label": "_t2: Ecxbdiv", + "range": { + "start": 98616, + "end": 98654 + }, + "inputs": [ + "ty", + "a", + "b" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxShiftExpr", + "label": "_t1: EcxShiftExpr", + "range": { + "start": 98659, + "end": 98695 + }, + "inputs": [ + "_t2" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "a", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "b", + "kind": "operand", + "index": 2 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "a", + "b", + "ty", + "x0", + "x1", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 98851, + "end": 98853 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "x1.handle().eq(&_t1.handle_a2())", + "semantic_text": "x1 == _t1.a2", + "referenced_vars": [ + "_t1", + "x1" + ], + "range": { + "start": 98871, + "end": 98873 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@223872:223949", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_shift_operand(pat.a, ctx.devalue(pat.x0), ctx.devalue(pat.x1))", + "semantic_text": null, + "referenced_pat_vars": [ + "a", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 223872, + "end": 223949 + } + }, + { + "id": "effect_1", + "effect_id": "effect@223968:224045", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_shift_operand(pat.b, ctx.devalue(pat.x0), ctx.devalue(pat.x1))", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 223968, + "end": 224045 + } + }, + { + "id": "effect_2", + "effect_id": "effect@224064:224098", + "bound_var": "t1", + "source_text": "ctx.insert_ecxbdiv(pat.ty, t2, t3)", + "semantic_text": null, + "referenced_pat_vars": [ + "ty" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 224064, + "end": 224098 + } + }, + { + "id": "effect_3", + "effect_id": "effect@224108:224130", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 224108, + "end": 224130 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0116", + "premises": [ + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "x1", + "label": "x1: ", + "plain_source": "x_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxShiftExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxbdiv", + "plain_source": "upright(\"bdiv\")(upright(\"ty\"), a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")", + "x_1 == upright(\"_t1.a2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"ShiftOperand\")(a, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"ShiftOperand\")(b, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"bdiv\")(upright(\"ty\"), (upright(\"ShiftOperand\")(a, x_0, x_1)), (upright(\"ShiftOperand\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_3", + "from": { + "target_id": "_t1", + "label": "_t1: EcxShiftExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"bdiv\")(upright(\"ty\"), (upright(\"ShiftOperand\")(a, x_0, x_1)), (upright(\"ShiftOperand\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(x_0 \\ x_1 \\ upright(\"_t1\") \\ upright(\"bdiv\")(upright(\"ty\"), a, b), upright(\"_t1\") arrow.r.double upright(\"bdiv\")(upright(\"ty\"), (upright(\"ShiftOperand\")(a, x_0, x_1)), (upright(\"ShiftOperand\")(b, x_0, x_1)))) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7224_5_MyTxEggccExtraction_add_rule__r0117__17fa2e5a65773f61", + "display_name": "r0117", + "rule_name": "r0117", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 224144, + "line": 7224, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 224144, + "end": 224499 + }, + "pattern_range": { + "start": 224191, + "end": 224202 + }, + "action_range": { + "start": 224204, + "end": 224498 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 99109, + "end": 99142 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 99147, + "end": 99180 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty: EcxType", + "range": { + "start": 99185, + "end": 99216 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 99221, + "end": 99268 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query", + "dsl_type": "", + "label": "x1: ", + "range": { + "start": 99273, + "end": 99320 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "Ecxblt", + "label": "_t2: Ecxblt", + "range": { + "start": 99325, + "end": 99362 + }, + "inputs": [ + "ty", + "a", + "b" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxShiftExpr", + "label": "_t1: EcxShiftExpr", + "range": { + "start": 99367, + "end": 99403 + }, + "inputs": [ + "_t2" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "a", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "b", + "kind": "operand", + "index": 2 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "a", + "b", + "ty", + "x0", + "x1", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 99559, + "end": 99561 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "x1.handle().eq(&_t1.handle_a2())", + "semantic_text": "x1 == _t1.a2", + "referenced_vars": [ + "_t1", + "x1" + ], + "range": { + "start": 99579, + "end": 99581 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@224234:224311", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_shift_operand(pat.a, ctx.devalue(pat.x0), ctx.devalue(pat.x1))", + "semantic_text": null, + "referenced_pat_vars": [ + "a", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 224234, + "end": 224311 + } + }, + { + "id": "effect_1", + "effect_id": "effect@224330:224407", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_shift_operand(pat.b, ctx.devalue(pat.x0), ctx.devalue(pat.x1))", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 224330, + "end": 224407 + } + }, + { + "id": "effect_2", + "effect_id": "effect@224426:224459", + "bound_var": "t1", + "source_text": "ctx.insert_ecxblt(pat.ty, t2, t3)", + "semantic_text": null, + "referenced_pat_vars": [ + "ty" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 224426, + "end": 224459 + } + }, + { + "id": "effect_3", + "effect_id": "effect@224469:224491", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 224469, + "end": 224491 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0117", + "premises": [ + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "x1", + "label": "x1: ", + "plain_source": "x_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxShiftExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: Ecxblt", + "plain_source": "upright(\"blt\")(upright(\"ty\"), a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")", + "x_1 == upright(\"_t1.a2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"ShiftOperand\")(a, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"ShiftOperand\")(b, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"blt\")(upright(\"ty\"), (upright(\"ShiftOperand\")(a, x_0, x_1)), (upright(\"ShiftOperand\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_3", + "from": { + "target_id": "_t1", + "label": "_t1: EcxShiftExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"blt\")(upright(\"ty\"), (upright(\"ShiftOperand\")(a, x_0, x_1)), (upright(\"ShiftOperand\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(x_0 \\ x_1 \\ upright(\"_t1\") \\ upright(\"blt\")(upright(\"ty\"), a, b), upright(\"_t1\") arrow.r.double upright(\"blt\")(upright(\"ty\"), (upright(\"ShiftOperand\")(a, x_0, x_1)), (upright(\"ShiftOperand\")(b, x_0, x_1)))) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7230_5_MyTxEggccExtraction_add_rule__r0118__26c7b5f5c84cb20d", + "display_name": "r0118", + "rule_name": "r0118", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 224505, + "line": 7230, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 224505, + "end": 224681 + }, + "pattern_range": { + "start": 224552, + "end": 224563 + }, + "action_range": { + "start": 224565, + "end": 224680 + } + }, + "nodes": [ + { + "id": "lit", + "kind": "query_leaf", + "dsl_type": "EcxLiteral", + "label": "lit: EcxLiteral", + "range": { + "start": 99824, + "end": 99859 + }, + "inputs": [] + }, + { + "id": "ops", + "kind": "query_leaf", + "dsl_type": "EcxConstOps", + "label": "ops: EcxConstOps", + "range": { + "start": 99864, + "end": 99900 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty: EcxType", + "range": { + "start": 99905, + "end": 99936 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 99941, + "end": 99988 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query", + "dsl_type": "", + "label": "x1: ", + "range": { + "start": 99993, + "end": 100040 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxConst", + "label": "_t2: EcxConst", + "range": { + "start": 100045, + "end": 100088 + }, + "inputs": [ + "ty", + "ops", + "lit" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxShiftExpr", + "label": "_t1: EcxShiftExpr", + "range": { + "start": 100093, + "end": 100129 + }, + "inputs": [ + "_t2" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "ops", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "lit", + "kind": "operand", + "index": 2 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "lit", + "ops", + "ty", + "x0", + "x1", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 100289, + "end": 100291 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "x1.handle().eq(&_t1.handle_a2())", + "semantic_text": "x1 == _t1.a2", + "referenced_vars": [ + "_t1", + "x1" + ], + "range": { + "start": 100309, + "end": 100311 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@224595:224641", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_const(pat.ty, pat.ops, pat.lit)", + "semantic_text": null, + "referenced_pat_vars": [ + "lit", + "ops", + "ty" + ], + "referenced_action_vars": [], + "range": { + "start": 224595, + "end": 224641 + } + }, + { + "id": "effect_1", + "effect_id": "effect@224651:224673", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 224651, + "end": 224673 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0118", + "premises": [ + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "x1", + "label": "x1: ", + "plain_source": "x_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxShiftExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxConst", + "plain_source": "upright(\"Const\")(upright(\"ty\"), upright(\"ops\"), upright(\"lit\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lit\") $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")", + "x_1 == upright(\"_t1.a2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"Const\")(upright(\"ty\"), upright(\"ops\"), upright(\"lit\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lit\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "_t1", + "label": "_t1: EcxShiftExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"Const\")(upright(\"ty\"), upright(\"ops\"), upright(\"lit\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lit\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(x_0 \\ x_1 \\ upright(\"_t1\") \\ upright(\"Const\")(upright(\"ty\"), upright(\"ops\"), upright(\"lit\")), upright(\"_t1\") arrow.r.double upright(\"Const\")(upright(\"ty\"), upright(\"ops\"), upright(\"lit\"))) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lit\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lit\") $]) $]) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7234_5_MyTxEggccExtraction_add_rule__r0119__c3094dfd4219ad3e", + "display_name": "r0119", + "rule_name": "r0119", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 224687, + "line": 7234, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 224687, + "end": 225008 + }, + "pattern_range": { + "start": 224734, + "end": 224745 + }, + "action_range": { + "start": 224747, + "end": 225007 + } + }, + "nodes": [ + { + "id": "args", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "args: EcxVecOperand", + "range": { + "start": 100573, + "end": 100612 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query", + "dsl_type": "", + "label": "f: ", + "range": { + "start": 100617, + "end": 100665 + }, + "inputs": [] + }, + { + "id": "n_outs", + "kind": "query", + "dsl_type": "", + "label": "n_outs: ", + "range": { + "start": 100670, + "end": 100725 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxOptionType", + "label": "ty: EcxOptionType", + "range": { + "start": 100730, + "end": 100767 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 100772, + "end": 100819 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query", + "dsl_type": "", + "label": "x1: ", + "range": { + "start": 100824, + "end": 100871 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxCall", + "label": "_t2: EcxCall", + "range": { + "start": 100876, + "end": 100913 + }, + "inputs": [ + "ty", + "args" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxShiftExpr", + "label": "_t1: EcxShiftExpr", + "range": { + "start": 100918, + "end": 100954 + }, + "inputs": [ + "_t2" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "args", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "args", + "f", + "n_outs", + "ty", + "x0", + "x1", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "f.handle().eq(&_t2.handle_a1())", + "semantic_text": "f == _t2.a1", + "referenced_vars": [ + "_t2", + "f" + ], + "range": { + "start": 101218, + "end": 101220 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "n_outs.handle().eq(&_t2.handle_a3())", + "semantic_text": "n_outs == _t2.a3", + "referenced_vars": [ + "_t2", + "n_outs" + ], + "range": { + "start": 101238, + "end": 101240 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 101258, + "end": 101260 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "x1.handle().eq(&_t1.handle_a2())", + "semantic_text": "x1 == _t1.a2", + "referenced_vars": [ + "_t1", + "x1" + ], + "range": { + "start": 101278, + "end": 101280 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@224789:224873", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_shift_vec_operand(pat.args, ctx.devalue(pat.x0), ctx.devalue(pat.x1))", + "semantic_text": null, + "referenced_pat_vars": [ + "args", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 224789, + "end": 224873 + } + }, + { + "id": "effect_1", + "effect_id": "effect@224892:224968", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_call(pat.ty, ctx.devalue(pat.f), t2, ctx.devalue(pat.n_outs))", + "semantic_text": null, + "referenced_pat_vars": [ + "f", + "n_outs", + "ty" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 224892, + "end": 224968 + } + }, + { + "id": "effect_2", + "effect_id": "effect@224978:225000", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 224978, + "end": 225000 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0119", + "premises": [ + { + "target_id": "f", + "label": "f: ", + "plain_source": "f", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ f $]" + }, + { + "target_id": "n_outs", + "label": "n_outs: ", + "plain_source": "upright(\"n_outs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"n_outs\") $]" + }, + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "x1", + "label": "x1: ", + "plain_source": "x_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxShiftExpr", + "plain_source": "upright(\"EcxShiftExpr\")(upright(\"_t2\"))", + "colored_source": "upright(\"EcxShiftExpr\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $])" + }, + { + "target_id": "_t2", + "label": "_t2: EcxCall", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + } + ], + "side_conditions": [ + "f == upright(\"_t2.a1\")", + "upright(\"n_outs\") == upright(\"_t2.a3\")", + "x_0 == upright(\"_t1.a1\")", + "x_1 == upright(\"_t1.a2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"ShiftVecOperand\")(upright(\"args\"), x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"args\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"Call\")(upright(\"ty\"), f, (upright(\"ShiftVecOperand\")(upright(\"args\"), x_0, x_1)), upright(\"n_outs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Call\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ f $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"args\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"n_outs\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "_t1", + "label": "_t1: EcxShiftExpr", + "plain_source": "upright(\"EcxShiftExpr\")(upright(\"_t2\"))", + "colored_source": "upright(\"EcxShiftExpr\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $])" + }, + "to": { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"Call\")(upright(\"ty\"), f, (upright(\"ShiftVecOperand\")(upright(\"args\"), x_0, x_1)), upright(\"n_outs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Call\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ f $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"args\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"n_outs\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(f \\ upright(\"n_outs\") \\ x_0 \\ x_1 \\ upright(\"EcxShiftExpr\")(upright(\"_t2\")) \\ upright(\"_t2\"), upright(\"EcxShiftExpr\")(upright(\"_t2\")) arrow.r.double upright(\"Call\")(upright(\"ty\"), f, (upright(\"ShiftVecOperand\")(upright(\"args\"), x_0, x_1)), upright(\"n_outs\"))) quad upright(\"if\") quad f == upright(\"_t2.a1\") \\ upright(\"n_outs\") == upright(\"_t2.a3\") \\ x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ f $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"n_outs\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $] \\ upright(\"EcxShiftExpr\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], upright(\"EcxShiftExpr\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]) arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Call\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ f $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"args\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"n_outs\") $]) $]) quad upright(\"if\") quad f == upright(\"_t2.a1\") \\ upright(\"n_outs\") == upright(\"_t2.a3\") \\ x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7240_5_MyTxEggccExtraction_add_rule__r0120__e3dc23d84f4457f1", + "display_name": "r0120", + "rule_name": "r0120", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 225014, + "line": 7240, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 225014, + "end": 225364 + }, + "pattern_range": { + "start": 225061, + "end": 225072 + }, + "action_range": { + "start": 225074, + "end": 225363 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 101501, + "end": 101534 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 101539, + "end": 101572 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 101577, + "end": 101624 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query", + "dsl_type": "", + "label": "x1: ", + "range": { + "start": 101629, + "end": 101676 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxPRINT", + "label": "_t2: EcxPRINT", + "range": { + "start": 101681, + "end": 101715 + }, + "inputs": [ + "a", + "b" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxShiftExpr", + "label": "_t1: EcxShiftExpr", + "range": { + "start": 101720, + "end": 101756 + }, + "inputs": [ + "_t2" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "a", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "b", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "a", + "b", + "x0", + "x1", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 101899, + "end": 101901 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "x1.handle().eq(&_t1.handle_a2())", + "semantic_text": "x1 == _t1.a2", + "referenced_vars": [ + "_t1", + "x1" + ], + "range": { + "start": 101910, + "end": 101912 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@225104:225181", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_shift_operand(pat.a, ctx.devalue(pat.x0), ctx.devalue(pat.x1))", + "semantic_text": null, + "referenced_pat_vars": [ + "a", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 225104, + "end": 225181 + } + }, + { + "id": "effect_1", + "effect_id": "effect@225200:225277", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_shift_operand(pat.b, ctx.devalue(pat.x0), ctx.devalue(pat.x1))", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 225200, + "end": 225277 + } + }, + { + "id": "effect_2", + "effect_id": "effect@225296:225324", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_print(t2, t3)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 225296, + "end": 225324 + } + }, + { + "id": "effect_3", + "effect_id": "effect@225334:225356", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 225334, + "end": 225356 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0120", + "premises": [ + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "x1", + "label": "x1: ", + "plain_source": "x_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxShiftExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxPRINT", + "plain_source": "upright(\"PRINT\")(a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PRINT\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")", + "x_1 == upright(\"_t1.a2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"ShiftOperand\")(a, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"ShiftOperand\")(b, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"EcxPrint\")(upright(\"ShiftOperand\")(a, x_0, x_1), upright(\"ShiftOperand\")(b, x_0, x_1))", + "colored_source": "upright(\"EcxPrint\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_3", + "from": { + "target_id": "_t1", + "label": "_t1: EcxShiftExpr", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"EcxPrint\")(upright(\"ShiftOperand\")(a, x_0, x_1), upright(\"ShiftOperand\")(b, x_0, x_1))", + "colored_source": "upright(\"EcxPrint\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])" + } + } + ], + "formula_source": { + "plain": "frac(x_0 \\ x_1 \\ upright(\"_t1\") \\ upright(\"PRINT\")(a, b), upright(\"_t1\") arrow.r.double upright(\"EcxPrint\")(upright(\"ShiftOperand\")(a, x_0, x_1), upright(\"ShiftOperand\")(b, x_0, x_1))) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PRINT\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double upright(\"EcxPrint\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7246_5_MyTxEggccExtraction_add_rule__r0121__3ee39f2ede5c1ba8", + "display_name": "r0121", + "rule_name": "r0121", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 225370, + "line": 7246, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 225370, + "end": 225536 + }, + "pattern_range": { + "start": 225417, + "end": 225428 + }, + "action_range": { + "start": 225430, + "end": 225535 + } + }, + "nodes": [ + { + "id": "amt", + "kind": "query", + "dsl_type": "", + "label": "amt: ", + "range": { + "start": 102140, + "end": 102189 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "f: EcxOperand", + "range": { + "start": 102194, + "end": 102227 + }, + "inputs": [] + }, + { + "id": "last_unshifted", + "kind": "query", + "dsl_type": "", + "label": "last_unshifted: ", + "range": { + "start": 102232, + "end": 102303 + }, + "inputs": [] + }, + { + "id": "x", + "kind": "query", + "dsl_type": "", + "label": "x: ", + "range": { + "start": 102308, + "end": 102353 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxArg", + "label": "_t2: EcxArg", + "range": { + "start": 102358, + "end": 102384 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxShiftOperand", + "label": "_t1: EcxShiftOperand", + "range": { + "start": 102389, + "end": 102428 + }, + "inputs": [ + "_t2" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "amt", + "f", + "last_unshifted", + "x", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x.handle().eq(&_t2.handle_a0())", + "semantic_text": "x == _t2.a0", + "referenced_vars": [ + "_t2", + "x" + ], + "range": { + "start": 102749, + "end": 102751 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "last_unshifted.handle().eq(&_t1.handle_a1())", + "semantic_text": "last_unshifted == _t1.a1", + "referenced_vars": [ + "_t1", + "last_unshifted" + ], + "range": { + "start": 102769, + "end": 102771 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "amt.handle().eq(&_t1.handle_a2())", + "semantic_text": "amt == _t1.a2", + "referenced_vars": [ + "_t1", + "amt" + ], + "range": { + "start": 102789, + "end": 102791 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 102809, + "end": 102811 + } + }, + { + "id": "constraint_4", + "source_text": "c4", + "resolved_text": "x.handle().le(&last_unshifted.handle())", + "semantic_text": "x <= last_unshifted", + "referenced_vars": [ + "last_unshifted", + "x" + ], + "range": { + "start": 102829, + "end": 102831 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@225460:225498", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_arg(ctx.devalue(pat.x))", + "semantic_text": null, + "referenced_pat_vars": [ + "x" + ], + "referenced_action_vars": [], + "range": { + "start": 225460, + "end": 225498 + } + }, + { + "id": "effect_1", + "effect_id": "effect@225508:225528", + "bound_var": null, + "source_text": "ctx.union(pat.f, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "f" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 225508, + "end": 225528 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0121", + "premises": [ + { + "target_id": "amt", + "label": "amt: ", + "plain_source": "upright(\"amt\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"amt\") $]" + }, + { + "target_id": "last_unshifted", + "label": "last_unshifted: ", + "plain_source": "upright(\"last_unshifted\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"last_unshifted\") $]" + }, + { + "target_id": "x", + "label": "x: ", + "plain_source": "x", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxShiftOperand", + "plain_source": "upright(\"EcxShiftOperand\")(upright(\"_t2\"))", + "colored_source": "upright(\"EcxShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $])" + }, + { + "target_id": "_t2", + "label": "_t2: EcxArg", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + } + ], + "side_conditions": [ + "x == upright(\"_t2.a0\")", + "upright(\"last_unshifted\") == upright(\"_t1.a1\")", + "upright(\"amt\") == upright(\"_t1.a2\")", + "f == upright(\"_t1\")", + "x <= upright(\"last_unshifted\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"Arg\")(x)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Arg\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "f", + "label": "f: EcxOperand", + "plain_source": "f", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ f $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"Arg\")(x)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Arg\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"amt\") \\ upright(\"last_unshifted\") \\ x \\ upright(\"EcxShiftOperand\")(upright(\"_t2\")) \\ upright(\"_t2\"), f arrow.r.double upright(\"Arg\")(x)) quad upright(\"if\") quad x == upright(\"_t2.a0\") \\ upright(\"last_unshifted\") == upright(\"_t1.a1\") \\ upright(\"amt\") == upright(\"_t1.a2\") \\ f == upright(\"_t1\") \\ x <= upright(\"last_unshifted\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"amt\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"last_unshifted\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x $] \\ upright(\"EcxShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ f $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Arg\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) $]) quad upright(\"if\") quad x == upright(\"_t2.a0\") \\ upright(\"last_unshifted\") == upright(\"_t1.a1\") \\ upright(\"amt\") == upright(\"_t1.a2\") \\ f == upright(\"_t1\") \\ x <= upright(\"last_unshifted\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7250_5_MyTxEggccExtraction_add_rule__r0122__45f4052382b1e68a", + "display_name": "r0122", + "rule_name": "r0122", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 225542, + "line": 7250, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 225542, + "end": 225733 + }, + "pattern_range": { + "start": 225589, + "end": 225600 + }, + "action_range": { + "start": 225602, + "end": 225732 + } + }, + "nodes": [ + { + "id": "amt", + "kind": "query", + "dsl_type": "", + "label": "amt: ", + "range": { + "start": 103059, + "end": 103108 + }, + "inputs": [] + }, + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "f: EcxOperand", + "range": { + "start": 103113, + "end": 103146 + }, + "inputs": [] + }, + { + "id": "last_unshifted", + "kind": "query", + "dsl_type": "", + "label": "last_unshifted: ", + "range": { + "start": 103151, + "end": 103222 + }, + "inputs": [] + }, + { + "id": "x", + "kind": "query", + "dsl_type": "", + "label": "x: ", + "range": { + "start": 103227, + "end": 103272 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxArg", + "label": "_t2: EcxArg", + "range": { + "start": 103277, + "end": 103303 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxShiftOperand", + "label": "_t1: EcxShiftOperand", + "range": { + "start": 103308, + "end": 103347 + }, + "inputs": [ + "_t2" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "amt", + "f", + "last_unshifted", + "x", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x.handle().eq(&_t2.handle_a0())", + "semantic_text": "x == _t2.a0", + "referenced_vars": [ + "_t2", + "x" + ], + "range": { + "start": 103668, + "end": 103670 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "last_unshifted.handle().eq(&_t1.handle_a1())", + "semantic_text": "last_unshifted == _t1.a1", + "referenced_vars": [ + "_t1", + "last_unshifted" + ], + "range": { + "start": 103688, + "end": 103690 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "amt.handle().eq(&_t1.handle_a2())", + "semantic_text": "amt == _t1.a2", + "referenced_vars": [ + "_t1", + "amt" + ], + "range": { + "start": 103708, + "end": 103710 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 103728, + "end": 103730 + } + }, + { + "id": "constraint_4", + "source_text": "c4", + "resolved_text": "x.handle().gt(&last_unshifted.handle())", + "semantic_text": "x > last_unshifted", + "referenced_vars": [ + "last_unshifted", + "x" + ], + "range": { + "start": 103748, + "end": 103750 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@225632:225695", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_arg((ctx.devalue(pat.x) + ctx.devalue(pat.amt)))", + "semantic_text": null, + "referenced_pat_vars": [ + "amt", + "x" + ], + "referenced_action_vars": [], + "range": { + "start": 225632, + "end": 225695 + } + }, + { + "id": "effect_1", + "effect_id": "effect@225705:225725", + "bound_var": null, + "source_text": "ctx.union(pat.f, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "f" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 225705, + "end": 225725 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0122", + "premises": [ + { + "target_id": "amt", + "label": "amt: ", + "plain_source": "upright(\"amt\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"amt\") $]" + }, + { + "target_id": "last_unshifted", + "label": "last_unshifted: ", + "plain_source": "upright(\"last_unshifted\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"last_unshifted\") $]" + }, + { + "target_id": "x", + "label": "x: ", + "plain_source": "x", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxShiftOperand", + "plain_source": "upright(\"EcxShiftOperand\")(upright(\"_t2\"))", + "colored_source": "upright(\"EcxShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $])" + }, + { + "target_id": "_t2", + "label": "_t2: EcxArg", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + } + ], + "side_conditions": [ + "x == upright(\"_t2.a0\")", + "upright(\"last_unshifted\") == upright(\"_t1.a1\")", + "upright(\"amt\") == upright(\"_t1.a2\")", + "f == upright(\"_t1\")", + "x > upright(\"last_unshifted\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"Arg\")(x + upright(\"amt\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Arg\")(#text(fill: rgb(\"#B86A5B\"))[$ x + upright(\"amt\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "f", + "label": "f: EcxOperand", + "plain_source": "f", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ f $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"Arg\")(x + upright(\"amt\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Arg\")(#text(fill: rgb(\"#B86A5B\"))[$ x + upright(\"amt\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"amt\") \\ upright(\"last_unshifted\") \\ x \\ upright(\"EcxShiftOperand\")(upright(\"_t2\")) \\ upright(\"_t2\"), f arrow.r.double upright(\"Arg\")(x + upright(\"amt\"))) quad upright(\"if\") quad x == upright(\"_t2.a0\") \\ upright(\"last_unshifted\") == upright(\"_t1.a1\") \\ upright(\"amt\") == upright(\"_t1.a2\") \\ f == upright(\"_t1\") \\ x > upright(\"last_unshifted\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"amt\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"last_unshifted\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x $] \\ upright(\"EcxShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ f $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Arg\")(#text(fill: rgb(\"#B86A5B\"))[$ x + upright(\"amt\") $]) $]) quad upright(\"if\") quad x == upright(\"_t2.a0\") \\ upright(\"last_unshifted\") == upright(\"_t1.a1\") \\ upright(\"amt\") == upright(\"_t1.a2\") \\ f == upright(\"_t1\") \\ x > upright(\"last_unshifted\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7254_5_MyTxEggccExtraction_add_rule__r0123__4594e44453382dd1", + "display_name": "r0123", + "rule_name": "r0123", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 225739, + "line": 7254, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 225739, + "end": 225985 + }, + "pattern_range": { + "start": 225786, + "end": 225797 + }, + "action_range": { + "start": 225799, + "end": 225984 + } + }, + "nodes": [ + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "b: EcxBody", + "range": { + "start": 103951, + "end": 103981 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 103986, + "end": 104033 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query", + "dsl_type": "", + "label": "x1: ", + "range": { + "start": 104038, + "end": 104085 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t2: EcxNode", + "range": { + "start": 104090, + "end": 104119 + }, + "inputs": [ + "b" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxShiftOperand", + "label": "_t1: EcxShiftOperand", + "range": { + "start": 104124, + "end": 104163 + }, + "inputs": [ + "_t2" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "b", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "b", + "x0", + "x1", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 104303, + "end": 104305 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "x1.handle().eq(&_t1.handle_a2())", + "semantic_text": "x1 == _t1.a2", + "referenced_vars": [ + "_t1", + "x1" + ], + "range": { + "start": 104314, + "end": 104316 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@225829:225903", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_shift_body(pat.b, ctx.devalue(pat.x0), ctx.devalue(pat.x1))", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 225829, + "end": 225903 + } + }, + { + "id": "effect_1", + "effect_id": "effect@225922:225945", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_node(t2)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 225922, + "end": 225945 + } + }, + { + "id": "effect_2", + "effect_id": "effect@225955:225977", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 225955, + "end": 225977 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0123", + "premises": [ + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "x1", + "label": "x1: ", + "plain_source": "x_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxShiftOperand", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxNode", + "plain_source": "upright(\"Node\")(b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")", + "x_1 == upright(\"_t1.a2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"ShiftBody\")(b, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"Node\")((upright(\"ShiftBody\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Node\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "_t1", + "label": "_t1: EcxShiftOperand", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"Node\")((upright(\"ShiftBody\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Node\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(x_0 \\ x_1 \\ upright(\"_t1\") \\ upright(\"Node\")(b), upright(\"_t1\") arrow.r.double upright(\"Node\")((upright(\"ShiftBody\")(b, x_0, x_1)))) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Node\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7259_5_MyTxEggccExtraction_add_rule__r0124__51534a95771f6367", + "display_name": "r0124", + "rule_name": "r0124", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 225991, + "line": 7259, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 225991, + "end": 226260 + }, + "pattern_range": { + "start": 226038, + "end": 226049 + }, + "action_range": { + "start": 226051, + "end": 226259 + } + }, + "nodes": [ + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "b: EcxBody", + "range": { + "start": 104532, + "end": 104562 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 104567, + "end": 104612 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 104617, + "end": 104664 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query", + "dsl_type": "", + "label": "x1: ", + "range": { + "start": 104669, + "end": 104716 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxProject", + "label": "_t2: EcxProject", + "range": { + "start": 104721, + "end": 104753 + }, + "inputs": [ + "b" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxShiftOperand", + "label": "_t1: EcxShiftOperand", + "range": { + "start": 104758, + "end": 104797 + }, + "inputs": [ + "_t2" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "b", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "b", + "i", + "x0", + "x1", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_t2.handle_a0())", + "semantic_text": "i == _t2.a0", + "referenced_vars": [ + "_t2", + "i" + ], + "range": { + "start": 104995, + "end": 104997 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 105015, + "end": 105017 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "x1.handle().eq(&_t1.handle_a2())", + "semantic_text": "x1 == _t1.a2", + "referenced_vars": [ + "_t1", + "x1" + ], + "range": { + "start": 105035, + "end": 105037 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@226081:226155", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_shift_body(pat.b, ctx.devalue(pat.x0), ctx.devalue(pat.x1))", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 226081, + "end": 226155 + } + }, + { + "id": "effect_1", + "effect_id": "effect@226174:226220", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_project(ctx.devalue(pat.i), t2)", + "semantic_text": null, + "referenced_pat_vars": [ + "i" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 226174, + "end": 226220 + } + }, + { + "id": "effect_2", + "effect_id": "effect@226230:226252", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 226230, + "end": 226252 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0124", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "x1", + "label": "x1: ", + "plain_source": "x_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxShiftOperand", + "plain_source": "upright(\"EcxShiftOperand\")(upright(\"_t2\"))", + "colored_source": "upright(\"EcxShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $])" + }, + { + "target_id": "_t2", + "label": "_t2: EcxProject", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + } + ], + "side_conditions": [ + "i == upright(\"_t2.a0\")", + "x_0 == upright(\"_t1.a1\")", + "x_1 == upright(\"_t1.a2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"ShiftBody\")(b, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"Project\")(i, (upright(\"ShiftBody\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Project\")(#text(fill: rgb(\"#5F7A8A\"))[$ i $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "_t1", + "label": "_t1: EcxShiftOperand", + "plain_source": "upright(\"EcxShiftOperand\")(upright(\"_t2\"))", + "colored_source": "upright(\"EcxShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $])" + }, + "to": { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"Project\")(i, (upright(\"ShiftBody\")(b, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Project\")(#text(fill: rgb(\"#5F7A8A\"))[$ i $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(i \\ x_0 \\ x_1 \\ upright(\"EcxShiftOperand\")(upright(\"_t2\")) \\ upright(\"_t2\"), upright(\"EcxShiftOperand\")(upright(\"_t2\")) arrow.r.double upright(\"Project\")(i, (upright(\"ShiftBody\")(b, x_0, x_1)))) quad upright(\"if\") quad i == upright(\"_t2.a0\") \\ x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $] \\ upright(\"EcxShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], upright(\"EcxShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]) arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Project\")(#text(fill: rgb(\"#5F7A8A\"))[$ i $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]) quad upright(\"if\") quad i == upright(\"_t2.a0\") \\ x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7264_5_MyTxEggccExtraction_add_rule__r0125__068bee29b670b4bc", + "display_name": "r0125", + "rule_name": "r0125", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 226266, + "line": 7264, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 226266, + "end": 226515 + }, + "pattern_range": { + "start": 226313, + "end": 226324 + }, + "action_range": { + "start": 226326, + "end": 226514 + } + }, + "nodes": [ + { + "id": "e", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "e: EcxExpr", + "range": { + "start": 105237, + "end": 105267 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 105272, + "end": 105319 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query", + "dsl_type": "", + "label": "x1: ", + "range": { + "start": 105324, + "end": 105371 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t2: EcxPureOp", + "range": { + "start": 105376, + "end": 105407 + }, + "inputs": [ + "e" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxShiftBody", + "label": "_t1: EcxShiftBody", + "range": { + "start": 105412, + "end": 105448 + }, + "inputs": [ + "_t2" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "e", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "e", + "x0", + "x1", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 105588, + "end": 105590 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "x1.handle().eq(&_t1.handle_a2())", + "semantic_text": "x1 == _t1.a2", + "referenced_vars": [ + "_t1", + "x1" + ], + "range": { + "start": 105599, + "end": 105601 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@226356:226430", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_shift_expr(pat.e, ctx.devalue(pat.x0), ctx.devalue(pat.x1))", + "semantic_text": null, + "referenced_pat_vars": [ + "e", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 226356, + "end": 226430 + } + }, + { + "id": "effect_1", + "effect_id": "effect@226449:226475", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_pure_op(t2)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 226449, + "end": 226475 + } + }, + { + "id": "effect_2", + "effect_id": "effect@226485:226507", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 226485, + "end": 226507 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0125", + "premises": [ + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "x1", + "label": "x1: ", + "plain_source": "x_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxShiftBody", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxPureOp", + "plain_source": "upright(\"PureOp\")(e)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")", + "x_1 == upright(\"_t1.a2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"ShiftExpr\")(e, x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftExpr\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"PureOp\")((upright(\"ShiftExpr\")(e, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftExpr\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "_t1", + "label": "_t1: EcxShiftBody", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"PureOp\")((upright(\"ShiftExpr\")(e, x_0, x_1)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftExpr\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(x_0 \\ x_1 \\ upright(\"_t1\") \\ upright(\"PureOp\")(e), upright(\"_t1\") arrow.r.double upright(\"PureOp\")((upright(\"ShiftExpr\")(e, x_0, x_1)))) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftExpr\")(#text(fill: rgb(\"#5F7A8A\"))[$ e $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $])) $]) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7269_5_MyTxEggccExtraction_add_rule__r0126__d98d0c61b1c84b82", + "display_name": "r0126", + "rule_name": "r0126", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 226521, + "line": 7269, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 226521, + "end": 226908 + }, + "pattern_range": { + "start": 226568, + "end": 226579 + }, + "action_range": { + "start": 226581, + "end": 226907 + } + }, + "nodes": [ + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 105864, + "end": 105905 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "outputs: EcxVecVecOperand", + "range": { + "start": 105910, + "end": 105955 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 105960, + "end": 105996 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 106001, + "end": 106048 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query", + "dsl_type": "", + "label": "x1: ", + "range": { + "start": 106053, + "end": 106100 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxGamma", + "label": "_t2: EcxGamma", + "range": { + "start": 106105, + "end": 106157 + }, + "inputs": [ + "pred", + "inputs", + "outputs" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxShiftBody", + "label": "_t1: EcxShiftBody", + "range": { + "start": 106162, + "end": 106198 + }, + "inputs": [ + "_t2" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "outputs", + "kind": "operand", + "index": 2 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "inputs", + "outputs", + "pred", + "x0", + "x1", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 106367, + "end": 106369 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "x1.handle().eq(&_t1.handle_a2())", + "semantic_text": "x1 == _t1.a2", + "referenced_vars": [ + "_t1", + "x1" + ], + "range": { + "start": 106387, + "end": 106389 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@226611:226691", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_shift_operand(pat.pred, ctx.devalue(pat.x0), ctx.devalue(pat.x1))", + "semantic_text": null, + "referenced_pat_vars": [ + "pred", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 226611, + "end": 226691 + } + }, + { + "id": "effect_1", + "effect_id": "effect@226722:226808", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_shift_vec_operand(pat.inputs, ctx.devalue(pat.x0), ctx.devalue(pat.x1))", + "semantic_text": null, + "referenced_pat_vars": [ + "inputs", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 226722, + "end": 226808 + } + }, + { + "id": "effect_2", + "effect_id": "effect@226827:226868", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_gamma(t2, t3, pat.outputs)", + "semantic_text": null, + "referenced_pat_vars": [ + "outputs" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 226827, + "end": 226868 + } + }, + { + "id": "effect_3", + "effect_id": "effect@226878:226900", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 226878, + "end": 226900 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0126", + "premises": [ + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "x1", + "label": "x1: ", + "plain_source": "x_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxShiftBody", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxGamma", + "plain_source": "upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")", + "x_1 == upright(\"_t1.a2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"ShiftOperand\")(upright(\"pred\"), x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"ShiftVecOperand\")(upright(\"inputs\"), x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"Gamma\")((upright(\"ShiftOperand\")(upright(\"pred\"), x_0, x_1)), (upright(\"ShiftVecOperand\")(upright(\"inputs\"), x_0, x_1)), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_3", + "from": { + "target_id": "_t1", + "label": "_t1: EcxShiftBody", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"Gamma\")((upright(\"ShiftOperand\")(upright(\"pred\"), x_0, x_1)), (upright(\"ShiftVecOperand\")(upright(\"inputs\"), x_0, x_1)), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(x_0 \\ x_1 \\ upright(\"_t1\") \\ upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\")), upright(\"_t1\") arrow.r.double upright(\"Gamma\")((upright(\"ShiftOperand\")(upright(\"pred\"), x_0, x_1)), (upright(\"ShiftVecOperand\")(upright(\"inputs\"), x_0, x_1)), upright(\"outputs\"))) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7276_5_MyTxEggccExtraction_add_rule__r0127__58a6f787c1335ad1", + "display_name": "r0127", + "rule_name": "r0127", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 226914, + "line": 7276, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 226914, + "end": 227208 + }, + "pattern_range": { + "start": 226961, + "end": 226972 + }, + "action_range": { + "start": 226974, + "end": 227207 + } + }, + "nodes": [ + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 106649, + "end": 106690 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "outputs: EcxVecOperand", + "range": { + "start": 106695, + "end": 106737 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 106742, + "end": 106778 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 106783, + "end": 106830 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query", + "dsl_type": "", + "label": "x1: ", + "range": { + "start": 106835, + "end": 106882 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxTheta", + "label": "_t2: EcxTheta", + "range": { + "start": 106887, + "end": 106939 + }, + "inputs": [ + "pred", + "inputs", + "outputs" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxShiftBody", + "label": "_t1: EcxShiftBody", + "range": { + "start": 106944, + "end": 106980 + }, + "inputs": [ + "_t2" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "outputs", + "kind": "operand", + "index": 2 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "inputs", + "outputs", + "pred", + "x0", + "x1", + "_t1", + "_t2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 107149, + "end": 107151 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "x1.handle().eq(&_t1.handle_a2())", + "semantic_text": "x1 == _t1.a2", + "referenced_vars": [ + "_t1", + "x1" + ], + "range": { + "start": 107169, + "end": 107171 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@227016:227102", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_shift_vec_operand(pat.inputs, ctx.devalue(pat.x0), ctx.devalue(pat.x1))", + "semantic_text": null, + "referenced_pat_vars": [ + "inputs", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 227016, + "end": 227102 + } + }, + { + "id": "effect_1", + "effect_id": "effect@227121:227168", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_theta(pat.pred, t2, pat.outputs)", + "semantic_text": null, + "referenced_pat_vars": [ + "outputs", + "pred" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 227121, + "end": 227168 + } + }, + { + "id": "effect_2", + "effect_id": "effect@227178:227200", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 227178, + "end": 227200 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0127", + "premises": [ + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "x1", + "label": "x1: ", + "plain_source": "x_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxShiftBody", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxTheta", + "plain_source": "upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")", + "x_1 == upright(\"_t1.a2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"ShiftVecOperand\")(upright(\"inputs\"), x_0, x_1)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"Theta\")(upright(\"pred\"), (upright(\"ShiftVecOperand\")(upright(\"inputs\"), x_0, x_1)), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "_t1", + "label": "_t1: EcxShiftBody", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"Theta\")(upright(\"pred\"), (upright(\"ShiftVecOperand\")(upright(\"inputs\"), x_0, x_1)), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(x_0 \\ x_1 \\ upright(\"_t1\") \\ upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\")), upright(\"_t1\") arrow.r.double upright(\"Theta\")(upright(\"pred\"), (upright(\"ShiftVecOperand\")(upright(\"inputs\"), x_0, x_1)), upright(\"outputs\"))) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ShiftVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7282_5_MyTxEggccExtraction_add_rule__r0128__abd40a1f2d837ed3", + "display_name": "r0128", + "rule_name": "r0128", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 227214, + "line": 7282, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 227214, + "end": 227500 + }, + "pattern_range": { + "start": 227261, + "end": 227272 + }, + "action_range": { + "start": 227274, + "end": 227499 + } + }, + "nodes": [ + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "vec: EcxVecOperand", + "range": { + "start": 107365, + "end": 107403 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 107408, + "end": 107455 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query", + "dsl_type": "", + "label": "x1: ", + "range": { + "start": 107460, + "end": 107507 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxShiftVecOperand", + "label": "_t1: EcxShiftVecOperand", + "range": { + "start": 107512, + "end": 107554 + }, + "inputs": [ + "vec" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "vec", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "vec", + "x0", + "x1", + "_t1" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 107691, + "end": 107693 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "x1.handle().eq(&_t1.handle_a2())", + "semantic_text": "x1 == _t1.a2", + "referenced_vars": [ + "_t1", + "x1" + ], + "range": { + "start": 107702, + "end": 107704 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@227304:227460", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_shift_vec_operand_helper(\n pat.vec,\n ctx.devalue(pat.x0),\n ctx.devalue(pat.x1),\n 0_i64,\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "vec", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 227304, + "end": 227460 + } + }, + { + "id": "effect_1", + "effect_id": "effect@227470:227492", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 227470, + "end": 227492 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0128", + "premises": [ + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "x1", + "label": "x1: ", + "plain_source": "x_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxShiftVecOperand", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")", + "x_1 == upright(\"_t1.a2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"EcxShiftVecOperandHelper\")(upright(\"vec\"), x_0, x_1, 0)", + "colored_source": "upright(\"EcxShiftVecOperandHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $], #text(fill: rgb(\"#B86A5B\"))[$ 0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "_t1", + "label": "_t1: EcxShiftVecOperand", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"EcxShiftVecOperandHelper\")(upright(\"vec\"), x_0, x_1, 0)", + "colored_source": "upright(\"EcxShiftVecOperandHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $], #text(fill: rgb(\"#B86A5B\"))[$ 0 $])" + } + } + ], + "formula_source": { + "plain": "frac(x_0 \\ x_1 \\ upright(\"_t1\"), upright(\"_t1\") arrow.r.double upright(\"EcxShiftVecOperandHelper\")(upright(\"vec\"), x_0, x_1, 0)) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double upright(\"EcxShiftVecOperandHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $], #text(fill: rgb(\"#B86A5B\"))[$ 0 $])) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7291_5_MyTxEggccExtraction_add_rule__r0129__2d414d5e794f4914", + "display_name": "r0129", + "rule_name": "r0129", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 227506, + "line": 7291, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 227506, + "end": 228545 + }, + "pattern_range": { + "start": 227553, + "end": 227564 + }, + "action_range": { + "start": 227566, + "end": 228544 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "f: EcxVecOperand", + "range": { + "start": 107989, + "end": 108025 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 108030, + "end": 108075 + }, + "inputs": [] + }, + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "vec: EcxVecOperandBase", + "range": { + "start": 108080, + "end": 108122 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 108127, + "end": 108174 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query", + "dsl_type": "", + "label": "x1: ", + "range": { + "start": 108179, + "end": 108226 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t2: EcxVO", + "range": { + "start": 108231, + "end": 108260 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxShiftVecOperand_helper", + "label": "_t1: EcxShiftVecOperand_helper", + "range": { + "start": 108265, + "end": 108314 + }, + "inputs": [ + "_t2" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t4: EcxVO", + "range": { + "start": 108319, + "end": 108348 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxVecOperand_length", + "label": "_f3: EcxVecOperand_length", + "range": { + "start": 108353, + "end": 108397 + }, + "inputs": [ + "_t4" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "_t4", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "f", + "i", + "vec", + "x0", + "x1", + "_t1", + "_t2", + "_f3", + "_t4" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 108696, + "end": 108698 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "x1.handle().eq(&_t1.handle_a2())", + "semantic_text": "x1 == _t1.a2", + "referenced_vars": [ + "_t1", + "x1" + ], + "range": { + "start": 108716, + "end": 108718 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "i.handle().eq(&_t1.handle_a3())", + "semantic_text": "i == _t1.a3", + "referenced_vars": [ + "_t1", + "i" + ], + "range": { + "start": 108736, + "end": 108738 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 108756, + "end": 108758 + } + }, + { + "id": "constraint_4", + "source_text": "c4", + "resolved_text": "i.handle().lt(&_f3.handle())", + "semantic_text": "i < _f3", + "referenced_vars": [ + "_f3", + "i" + ], + "range": { + "start": 108776, + "end": 108778 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@227596:227622", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_vo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 227596, + "end": 227622 + } + }, + { + "id": "effect_1", + "effect_id": "effect@227641:227805", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_shift_vec_operand_helper(\n t2,\n ctx.devalue(pat.x0),\n ctx.devalue(pat.x1),\n ctx.devalue(pat.i),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "i", + "x0", + "x1" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 227641, + "end": 227805 + } + }, + { + "id": "effect_2", + "effect_id": "effect@227824:227850", + "bound_var": "t7", + "source_text": "ctx.insert_ecx_vo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 227824, + "end": 227850 + } + }, + { + "id": "effect_3", + "effect_id": "effect@227869:227923", + "bound_var": "t6", + "source_text": "ctx.insert_ecx_vec_operand_get(t7, ctx.devalue(pat.i))", + "semantic_text": null, + "referenced_pat_vars": [ + "i" + ], + "referenced_action_vars": [ + "t7" + ], + "range": { + "start": 227869, + "end": 227923 + } + }, + { + "id": "effect_4", + "effect_id": "effect@227942:228016", + "bound_var": "t5", + "source_text": "ctx.insert_ecx_shift_operand(t6, ctx.devalue(pat.x0), ctx.devalue(pat.x1))", + "semantic_text": null, + "referenced_pat_vars": [ + "x0", + "x1" + ], + "referenced_action_vars": [ + "t6" + ], + "range": { + "start": 227942, + "end": 228016 + } + }, + { + "id": "effect_5", + "effect_id": "effect@228035:228317", + "bound_var": "t4", + "source_text": "ctx.insert_ecx_vo(\n ctx.intern_container::>(vec_set::<\n EcxOperand,\n >(\n &*ctx.devalue(pat.vec),\n ctx.devalue(pat.i),\n t5.erase(),\n )),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "i", + "vec" + ], + "referenced_action_vars": [ + "t5" + ], + "range": { + "start": 228035, + "end": 228317 + } + }, + { + "id": "effect_6", + "effect_id": "effect@228336:228510", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_shift_vec_operand_helper(\n t4,\n ctx.devalue(pat.x0),\n ctx.devalue(pat.x1),\n (ctx.devalue(pat.i) + 1_i64),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "i", + "x0", + "x1" + ], + "referenced_action_vars": [ + "t4" + ], + "range": { + "start": 228336, + "end": 228510 + } + }, + { + "id": "effect_7", + "effect_id": "effect@228520:228537", + "bound_var": null, + "source_text": "ctx.union(t1, t3)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t1", + "t3" + ], + "range": { + "start": 228520, + "end": 228537 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0129", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "x1", + "label": "x1: ", + "plain_source": "x_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxShiftVecOperand_helper", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxVecOperand_length", + "plain_source": "upright(\"EcxVecOperand_length\")(upright(\"VO\")(upright(\"vec\")))", + "colored_source": "upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")", + "x_1 == upright(\"_t1.a2\")", + "i == upright(\"_t1.a3\")", + "f == upright(\"_t1\")", + "i < upright(\"_f3\")" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(i \\ x_0 \\ x_1 \\ upright(\"_t1\") \\ upright(\"VO\")(upright(\"vec\")) \\ upright(\"EcxVecOperand_length\")(upright(\"VO\")(upright(\"vec\"))) \\ upright(\"VO\")(upright(\"vec\")), upright(\"no conclusion\")) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\") \\ i == upright(\"_t1.a3\") \\ f == upright(\"_t1\") \\ i < upright(\"_f3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $] \\ upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], upright(\"no conclusion\")) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\") \\ i == upright(\"_t1.a3\") \\ f == upright(\"_t1\") \\ i < upright(\"_f3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7319_5_MyTxEggccExtraction_add_rule__r0130__0c532a6473c5573d", + "display_name": "r0130", + "rule_name": "r0130", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 228551, + "line": 7319, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 228551, + "end": 228930 + }, + "pattern_range": { + "start": 228598, + "end": 228609 + }, + "action_range": { + "start": 228611, + "end": 228929 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "f: EcxVecOperand", + "range": { + "start": 109063, + "end": 109099 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 109104, + "end": 109149 + }, + "inputs": [] + }, + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "vec: EcxVecOperandBase", + "range": { + "start": 109154, + "end": 109196 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 109201, + "end": 109248 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query", + "dsl_type": "", + "label": "x1: ", + "range": { + "start": 109253, + "end": 109300 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t2: EcxVO", + "range": { + "start": 109305, + "end": 109334 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxShiftVecOperand_helper", + "label": "_t1: EcxShiftVecOperand_helper", + "range": { + "start": 109339, + "end": 109388 + }, + "inputs": [ + "_t2" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t4: EcxVO", + "range": { + "start": 109393, + "end": 109422 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxVecOperand_length", + "label": "_f3: EcxVecOperand_length", + "range": { + "start": 109427, + "end": 109471 + }, + "inputs": [ + "_t4" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "_t4", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "f", + "i", + "vec", + "x0", + "x1", + "_t1", + "_t2", + "_f3", + "_t4" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 109770, + "end": 109772 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "x1.handle().eq(&_t1.handle_a2())", + "semantic_text": "x1 == _t1.a2", + "referenced_vars": [ + "_t1", + "x1" + ], + "range": { + "start": 109790, + "end": 109792 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "i.handle().eq(&_t1.handle_a3())", + "semantic_text": "i == _t1.a3", + "referenced_vars": [ + "_t1", + "i" + ], + "range": { + "start": 109810, + "end": 109812 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 109830, + "end": 109832 + } + }, + { + "id": "constraint_4", + "source_text": "c4", + "resolved_text": "i.handle().eq(&_f3.handle())", + "semantic_text": "i == _f3", + "referenced_vars": [ + "_f3", + "i" + ], + "range": { + "start": 109850, + "end": 109852 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@228641:228667", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_vo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 228641, + "end": 228667 + } + }, + { + "id": "effect_1", + "effect_id": "effect@228686:228850", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_shift_vec_operand_helper(\n t2,\n ctx.devalue(pat.x0),\n ctx.devalue(pat.x1),\n ctx.devalue(pat.i),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "i", + "x0", + "x1" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 228686, + "end": 228850 + } + }, + { + "id": "effect_2", + "effect_id": "effect@228869:228895", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_vo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 228869, + "end": 228895 + } + }, + { + "id": "effect_3", + "effect_id": "effect@228905:228922", + "bound_var": null, + "source_text": "ctx.union(t1, t3)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t1", + "t3" + ], + "range": { + "start": 228905, + "end": 228922 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0130", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "x1", + "label": "x1: ", + "plain_source": "x_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxShiftVecOperand_helper", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxVecOperand_length", + "plain_source": "upright(\"EcxVecOperand_length\")(upright(\"VO\")(upright(\"vec\")))", + "colored_source": "upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")", + "x_1 == upright(\"_t1.a2\")", + "i == upright(\"_t1.a3\")", + "f == upright(\"_t1\")", + "i == upright(\"_f3\")" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(i \\ x_0 \\ x_1 \\ upright(\"_t1\") \\ upright(\"VO\")(upright(\"vec\")) \\ upright(\"EcxVecOperand_length\")(upright(\"VO\")(upright(\"vec\"))) \\ upright(\"VO\")(upright(\"vec\")), upright(\"no conclusion\")) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\") \\ i == upright(\"_t1.a3\") \\ f == upright(\"_t1\") \\ i == upright(\"_f3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $] \\ upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], upright(\"no conclusion\")) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\") \\ i == upright(\"_t1.a3\") \\ f == upright(\"_t1\") \\ i == upright(\"_f3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7330_5_MyTxEggccExtraction_add_rule__r0131__6134bf4ed8127e5f", + "display_name": "r0131", + "rule_name": "r0131", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 228936, + "line": 7330, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 228936, + "end": 229226 + }, + "pattern_range": { + "start": 228983, + "end": 228994 + }, + "action_range": { + "start": 228996, + "end": 229225 + } + }, + "nodes": [ + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "vec: EcxVecVecOperand", + "range": { + "start": 110052, + "end": 110093 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 110098, + "end": 110145 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query", + "dsl_type": "", + "label": "x1: ", + "range": { + "start": 110150, + "end": 110197 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxShiftVecVecOperand", + "label": "_t1: EcxShiftVecVecOperand", + "range": { + "start": 110202, + "end": 110247 + }, + "inputs": [ + "vec" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "vec", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "vec", + "x0", + "x1", + "_t1" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 110384, + "end": 110386 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "x1.handle().eq(&_t1.handle_a2())", + "semantic_text": "x1 == _t1.a2", + "referenced_vars": [ + "_t1", + "x1" + ], + "range": { + "start": 110395, + "end": 110397 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@229026:229186", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_shift_vec_vec_operand_helper(\n pat.vec,\n ctx.devalue(pat.x0),\n ctx.devalue(pat.x1),\n 0_i64,\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "vec", + "x0", + "x1" + ], + "referenced_action_vars": [], + "range": { + "start": 229026, + "end": 229186 + } + }, + { + "id": "effect_1", + "effect_id": "effect@229196:229218", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 229196, + "end": 229218 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0131", + "premises": [ + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "x1", + "label": "x1: ", + "plain_source": "x_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxShiftVecVecOperand", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")", + "x_1 == upright(\"_t1.a2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"EcxShiftVecVecOperandHelper\")(upright(\"vec\"), x_0, x_1, 0)", + "colored_source": "upright(\"EcxShiftVecVecOperandHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $], #text(fill: rgb(\"#B86A5B\"))[$ 0 $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "_t1", + "label": "_t1: EcxShiftVecVecOperand", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"EcxShiftVecVecOperandHelper\")(upright(\"vec\"), x_0, x_1, 0)", + "colored_source": "upright(\"EcxShiftVecVecOperandHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $], #text(fill: rgb(\"#B86A5B\"))[$ 0 $])" + } + } + ], + "formula_source": { + "plain": "frac(x_0 \\ x_1 \\ upright(\"_t1\"), upright(\"_t1\") arrow.r.double upright(\"EcxShiftVecVecOperandHelper\")(upright(\"vec\"), x_0, x_1, 0)) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double upright(\"EcxShiftVecVecOperandHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $], #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $], #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $], #text(fill: rgb(\"#B86A5B\"))[$ 0 $])) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7339_5_MyTxEggccExtraction_add_rule__r0132__ffea83ea289bab4d", + "display_name": "r0132", + "rule_name": "r0132", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 229232, + "line": 7339, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 229232, + "end": 230299 + }, + "pattern_range": { + "start": 229279, + "end": 229290 + }, + "action_range": { + "start": 229292, + "end": 230298 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "f: EcxVecVecOperand", + "range": { + "start": 110693, + "end": 110732 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 110737, + "end": 110782 + }, + "inputs": [] + }, + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperandBase", + "label": "vec: EcxVecVecOperandBase", + "range": { + "start": 110787, + "end": 110832 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 110837, + "end": 110884 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query", + "dsl_type": "", + "label": "x1: ", + "range": { + "start": 110889, + "end": 110936 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t2: EcxVVO", + "range": { + "start": 110941, + "end": 110971 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxShiftVecVecOperand_helper", + "label": "_t1: EcxShiftVecVecOperand_helper", + "range": { + "start": 110976, + "end": 111028 + }, + "inputs": [ + "_t2" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t4: EcxVVO", + "range": { + "start": 111033, + "end": 111063 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxVecVecOperand_length", + "label": "_f3: EcxVecVecOperand_length", + "range": { + "start": 111068, + "end": 111115 + }, + "inputs": [ + "_t4" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "_t4", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "f", + "i", + "vec", + "x0", + "x1", + "_t1", + "_t2", + "_f3", + "_t4" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 111414, + "end": 111416 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "x1.handle().eq(&_t1.handle_a2())", + "semantic_text": "x1 == _t1.a2", + "referenced_vars": [ + "_t1", + "x1" + ], + "range": { + "start": 111434, + "end": 111436 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "i.handle().eq(&_t1.handle_a3())", + "semantic_text": "i == _t1.a3", + "referenced_vars": [ + "_t1", + "i" + ], + "range": { + "start": 111454, + "end": 111456 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 111474, + "end": 111476 + } + }, + { + "id": "constraint_4", + "source_text": "c4", + "resolved_text": "i.handle().lt(&_f3.handle())", + "semantic_text": "i < _f3", + "referenced_vars": [ + "_f3", + "i" + ], + "range": { + "start": 111494, + "end": 111496 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@229322:229349", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_vvo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 229322, + "end": 229349 + } + }, + { + "id": "effect_1", + "effect_id": "effect@229368:229536", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_shift_vec_vec_operand_helper(\n t2,\n ctx.devalue(pat.x0),\n ctx.devalue(pat.x1),\n ctx.devalue(pat.i),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "i", + "x0", + "x1" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 229368, + "end": 229536 + } + }, + { + "id": "effect_2", + "effect_id": "effect@229555:229582", + "bound_var": "t7", + "source_text": "ctx.insert_ecx_vvo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 229555, + "end": 229582 + } + }, + { + "id": "effect_3", + "effect_id": "effect@229601:229659", + "bound_var": "t6", + "source_text": "ctx.insert_ecx_vec_vec_operand_get(t7, ctx.devalue(pat.i))", + "semantic_text": null, + "referenced_pat_vars": [ + "i" + ], + "referenced_action_vars": [ + "t7" + ], + "range": { + "start": 229601, + "end": 229659 + } + }, + { + "id": "effect_4", + "effect_id": "effect@229678:229756", + "bound_var": "t5", + "source_text": "ctx.insert_ecx_shift_vec_operand(t6, ctx.devalue(pat.x0), ctx.devalue(pat.x1))", + "semantic_text": null, + "referenced_pat_vars": [ + "x0", + "x1" + ], + "referenced_action_vars": [ + "t6" + ], + "range": { + "start": 229678, + "end": 229756 + } + }, + { + "id": "effect_5", + "effect_id": "effect@229775:230067", + "bound_var": "t4", + "source_text": "ctx.insert_ecx_vvo(\n ctx.intern_container::>(vec_set::<\n EcxVecOperand,\n >(\n &*ctx.devalue(pat.vec),\n ctx.devalue(pat.i),\n t5.erase(),\n )),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "i", + "vec" + ], + "referenced_action_vars": [ + "t5" + ], + "range": { + "start": 229775, + "end": 230067 + } + }, + { + "id": "effect_6", + "effect_id": "effect@230086:230264", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_shift_vec_vec_operand_helper(\n t4,\n ctx.devalue(pat.x0),\n ctx.devalue(pat.x1),\n (ctx.devalue(pat.i) + 1_i64),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "i", + "x0", + "x1" + ], + "referenced_action_vars": [ + "t4" + ], + "range": { + "start": 230086, + "end": 230264 + } + }, + { + "id": "effect_7", + "effect_id": "effect@230274:230291", + "bound_var": null, + "source_text": "ctx.union(t1, t3)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t1", + "t3" + ], + "range": { + "start": 230274, + "end": 230291 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0132", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "x1", + "label": "x1: ", + "plain_source": "x_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxShiftVecVecOperand_helper", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxVecVecOperand_length", + "plain_source": "upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(upright(\"vec\")))", + "colored_source": "upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")", + "x_1 == upright(\"_t1.a2\")", + "i == upright(\"_t1.a3\")", + "f == upright(\"_t1\")", + "i < upright(\"_f3\")" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(i \\ x_0 \\ x_1 \\ upright(\"_t1\") \\ upright(\"VVO\")(upright(\"vec\")) \\ upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(upright(\"vec\"))) \\ upright(\"VVO\")(upright(\"vec\")), upright(\"no conclusion\")) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\") \\ i == upright(\"_t1.a3\") \\ f == upright(\"_t1\") \\ i < upright(\"_f3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $] \\ upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], upright(\"no conclusion\")) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\") \\ i == upright(\"_t1.a3\") \\ f == upright(\"_t1\") \\ i < upright(\"_f3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7367_5_MyTxEggccExtraction_add_rule__r0133__96ab14873c3f03a9", + "display_name": "r0133", + "rule_name": "r0133", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 230305, + "line": 7367, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 230305, + "end": 230690 + }, + "pattern_range": { + "start": 230352, + "end": 230363 + }, + "action_range": { + "start": 230365, + "end": 230689 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "f: EcxVecVecOperand", + "range": { + "start": 111792, + "end": 111831 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 111836, + "end": 111881 + }, + "inputs": [] + }, + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperandBase", + "label": "vec: EcxVecVecOperandBase", + "range": { + "start": 111886, + "end": 111931 + }, + "inputs": [] + }, + { + "id": "x0", + "kind": "query", + "dsl_type": "", + "label": "x0: ", + "range": { + "start": 111936, + "end": 111983 + }, + "inputs": [] + }, + { + "id": "x1", + "kind": "query", + "dsl_type": "", + "label": "x1: ", + "range": { + "start": 111988, + "end": 112035 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t2: EcxVVO", + "range": { + "start": 112040, + "end": 112070 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxShiftVecVecOperand_helper", + "label": "_t1: EcxShiftVecVecOperand_helper", + "range": { + "start": 112075, + "end": 112127 + }, + "inputs": [ + "_t2" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t4: EcxVVO", + "range": { + "start": 112132, + "end": 112162 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxVecVecOperand_length", + "label": "_f3: EcxVecVecOperand_length", + "range": { + "start": 112167, + "end": 112214 + }, + "inputs": [ + "_t4" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "_t4", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "f", + "i", + "vec", + "x0", + "x1", + "_t1", + "_t2", + "_f3", + "_t4" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "x0.handle().eq(&_t1.handle_a1())", + "semantic_text": "x0 == _t1.a1", + "referenced_vars": [ + "_t1", + "x0" + ], + "range": { + "start": 112513, + "end": 112515 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "x1.handle().eq(&_t1.handle_a2())", + "semantic_text": "x1 == _t1.a2", + "referenced_vars": [ + "_t1", + "x1" + ], + "range": { + "start": 112533, + "end": 112535 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "i.handle().eq(&_t1.handle_a3())", + "semantic_text": "i == _t1.a3", + "referenced_vars": [ + "_t1", + "i" + ], + "range": { + "start": 112553, + "end": 112555 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "f.handle().eq(&_t1.handle())", + "semantic_text": "f == _t1", + "referenced_vars": [ + "_t1", + "f" + ], + "range": { + "start": 112573, + "end": 112575 + } + }, + { + "id": "constraint_4", + "source_text": "c4", + "resolved_text": "i.handle().eq(&_f3.handle())", + "semantic_text": "i == _f3", + "referenced_vars": [ + "_f3", + "i" + ], + "range": { + "start": 112593, + "end": 112595 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@230395:230422", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_vvo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 230395, + "end": 230422 + } + }, + { + "id": "effect_1", + "effect_id": "effect@230441:230609", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_shift_vec_vec_operand_helper(\n t2,\n ctx.devalue(pat.x0),\n ctx.devalue(pat.x1),\n ctx.devalue(pat.i),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "i", + "x0", + "x1" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 230441, + "end": 230609 + } + }, + { + "id": "effect_2", + "effect_id": "effect@230628:230655", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_vvo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 230628, + "end": 230655 + } + }, + { + "id": "effect_3", + "effect_id": "effect@230665:230682", + "bound_var": null, + "source_text": "ctx.union(t1, t3)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t1", + "t3" + ], + "range": { + "start": 230665, + "end": 230682 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0133", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "x0", + "label": "x0: ", + "plain_source": "x_0", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_0 $]" + }, + { + "target_id": "x1", + "label": "x1: ", + "plain_source": "x_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxShiftVecVecOperand_helper", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxVecVecOperand_length", + "plain_source": "upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(upright(\"vec\")))", + "colored_source": "upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + } + ], + "side_conditions": [ + "x_0 == upright(\"_t1.a1\")", + "x_1 == upright(\"_t1.a2\")", + "i == upright(\"_t1.a3\")", + "f == upright(\"_t1\")", + "i == upright(\"_f3\")" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(i \\ x_0 \\ x_1 \\ upright(\"_t1\") \\ upright(\"VVO\")(upright(\"vec\")) \\ upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(upright(\"vec\"))) \\ upright(\"VVO\")(upright(\"vec\")), upright(\"no conclusion\")) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\") \\ i == upright(\"_t1.a3\") \\ f == upright(\"_t1\") \\ i == upright(\"_f3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_0 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ x_1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $] \\ upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], upright(\"no conclusion\")) quad upright(\"if\") quad x_0 == upright(\"_t1.a1\") \\ x_1 == upright(\"_t1.a2\") \\ i == upright(\"_t1.a3\") \\ f == upright(\"_t1\") \\ i == upright(\"_f3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7378_5_MyTxEggccExtraction_add_rule__r0134__aacfafa21b46731c", + "display_name": "r0134", + "rule_name": "r0134", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 230696, + "line": 7378, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 230696, + "end": 231100 + }, + "pattern_range": { + "start": 230742, + "end": 230753 + }, + "action_range": { + "start": 230755, + "end": 231099 + } + }, + "nodes": [ + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 112756, + "end": 112801 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxPassThroughArguments", + "label": "_t1: EcxPassThroughArguments", + "range": { + "start": 112806, + "end": 112849 + }, + "inputs": [] + } + ], + "edges": [], + "roots": [ + "i", + "_t1" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_t1.handle_a0())", + "semantic_text": "i == _t1.a0", + "referenced_vars": [ + "_t1", + "i" + ], + "range": { + "start": 112928, + "end": 112930 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@230785:230973", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_vo(\n ctx.intern_container::>(VecContainer::<\n EcxOperand,\n >::new(\n )),\n )", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 230785, + "end": 230973 + } + }, + { + "id": "effect_1", + "effect_id": "effect@230992:231060", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_pass_through_arguments_helper(ctx.devalue(pat.i), t2)", + "semantic_text": null, + "referenced_pat_vars": [ + "i" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 230992, + "end": 231060 + } + }, + { + "id": "effect_2", + "effect_id": "effect@231070:231092", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 231070, + "end": 231092 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0134", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxPassThroughArguments", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + } + ], + "side_conditions": [ + "i == upright(\"_t1.a0\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"EcxVo\")(upright(\"intern_container\")::>(upright(\"VecContainer\")::< upright(\"EcxOperand\"), >::upright(\"new\")()))", + "colored_source": "upright(\"EcxVo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"VecContainer\")::< upright(\"EcxOperand\"), >::upright(\"new\")()) $])" + }, + { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"PassThroughArgumentsHelper\")(i, upright(\"EcxVo\")(upright(\"intern_container\")::>(upright(\"VecContainer\")::< upright(\"EcxOperand\"), >::upright(\"new\")())))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PassThroughArgumentsHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ i $], upright(\"EcxVo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"VecContainer\")::< upright(\"EcxOperand\"), >::upright(\"new\")()) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "_t1", + "label": "_t1: EcxPassThroughArguments", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"PassThroughArgumentsHelper\")(i, upright(\"EcxVo\")(upright(\"intern_container\")::>(upright(\"VecContainer\")::< upright(\"EcxOperand\"), >::upright(\"new\")())))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PassThroughArgumentsHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ i $], upright(\"EcxVo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"VecContainer\")::< upright(\"EcxOperand\"), >::upright(\"new\")()) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(i \\ upright(\"_t1\"), upright(\"_t1\") arrow.r.double upright(\"PassThroughArgumentsHelper\")(i, upright(\"EcxVo\")(upright(\"intern_container\")::>(upright(\"VecContainer\")::< upright(\"EcxOperand\"), >::upright(\"new\")())))) quad upright(\"if\") quad i == upright(\"_t1.a0\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"PassThroughArgumentsHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ i $], upright(\"EcxVo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"VecContainer\")::< upright(\"EcxOperand\"), >::upright(\"new\")()) $])) $]) quad upright(\"if\") quad i == upright(\"_t1.a0\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7388_5_MyTxEggccExtraction_add_rule__r0135__fb9dc99db8cb5dd8", + "display_name": "r0135", + "rule_name": "r0135", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 231106, + "line": 7388, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 231106, + "end": 231641 + }, + "pattern_range": { + "start": 231152, + "end": 231163 + }, + "action_range": { + "start": 231165, + "end": 231640 + } + }, + "nodes": [ + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 113196, + "end": 113241 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "lhs: EcxVecOperand", + "range": { + "start": 113246, + "end": 113284 + }, + "inputs": [] + }, + { + "id": "rest", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "rest: EcxVecOperandBase", + "range": { + "start": 113289, + "end": 113332 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t2: EcxVO", + "range": { + "start": 113337, + "end": 113367 + }, + "inputs": [ + "rest" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxPassThroughArgumentsHelper", + "label": "_t1: EcxPassThroughArgumentsHelper", + "range": { + "start": 113372, + "end": 113425 + }, + "inputs": [ + "_t2" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t4: EcxVO", + "range": { + "start": 113430, + "end": 113460 + }, + "inputs": [ + "rest" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxVecOperand_length", + "label": "_f3: EcxVecOperand_length", + "range": { + "start": 113465, + "end": 113509 + }, + "inputs": [ + "_t4" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "rest", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "rest", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "_t4", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "i", + "lhs", + "rest", + "_t1", + "_t2", + "_f3", + "_t4" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_t1.handle_a0())", + "semantic_text": "i == _t1.a0", + "referenced_vars": [ + "_t1", + "i" + ], + "range": { + "start": 113711, + "end": 113713 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 113731, + "end": 113733 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "_f3.handle().lt(&i.handle())", + "semantic_text": "_f3 < i", + "referenced_vars": [ + "_f3", + "i" + ], + "range": { + "start": 113751, + "end": 113753 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@231195:231247", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_arg(vec_len(&*ctx.devalue(pat.rest)))", + "semantic_text": null, + "referenced_pat_vars": [ + "rest" + ], + "referenced_action_vars": [], + "range": { + "start": 231195, + "end": 231247 + } + }, + { + "id": "effect_1", + "effect_id": "effect@231266:231514", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_vo(\n ctx.intern_container::>(vec_push::<\n EcxOperand,\n >(\n &*ctx.devalue(pat.rest),\n t3.erase(),\n )),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "rest" + ], + "referenced_action_vars": [ + "t3" + ], + "range": { + "start": 231266, + "end": 231514 + } + }, + { + "id": "effect_2", + "effect_id": "effect@231533:231601", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_pass_through_arguments_helper(ctx.devalue(pat.i), t2)", + "semantic_text": null, + "referenced_pat_vars": [ + "i" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 231533, + "end": 231601 + } + }, + { + "id": "effect_3", + "effect_id": "effect@231611:231633", + "bound_var": null, + "source_text": "ctx.union(pat.lhs, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 231611, + "end": 231633 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0135", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxPassThroughArgumentsHelper", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"rest\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rest\") $]) $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxVecOperand_length", + "plain_source": "upright(\"EcxVecOperand_length\")(upright(\"VO\")(upright(\"rest\")))", + "colored_source": "upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rest\") $]) $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"rest\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rest\") $]) $]" + } + ], + "side_conditions": [ + "i == upright(\"_t1.a0\")", + "upright(\"lhs\") == upright(\"_t1\")", + "upright(\"_f3\") < i" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t3", + "plain_source": "upright(\"Arg\")(upright(\"vec_len\")(*upright(\"rest\")))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Arg\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"vec_len\")(*upright(\"rest\")) $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t2", + "plain_source": "upright(\"EcxVo\")(upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"rest\"), upright(\"t3.erase\")())))", + "colored_source": "upright(\"EcxVo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"rest\"), upright(\"t3.erase\")())) $])" + }, + { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"PassThroughArgumentsHelper\")(i, upright(\"EcxVo\")(upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"rest\"), upright(\"t3.erase\")()))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PassThroughArgumentsHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ i $], upright(\"EcxVo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"rest\"), upright(\"t3.erase\")())) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_3", + "from": { + "target_id": "lhs", + "label": "lhs: EcxVecOperand", + "plain_source": "upright(\"lhs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]" + }, + "to": { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"PassThroughArgumentsHelper\")(i, upright(\"EcxVo\")(upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"rest\"), upright(\"t3.erase\")()))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PassThroughArgumentsHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ i $], upright(\"EcxVo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"rest\"), upright(\"t3.erase\")())) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(i \\ upright(\"_t1\") \\ upright(\"VO\")(upright(\"rest\")) \\ upright(\"EcxVecOperand_length\")(upright(\"VO\")(upright(\"rest\"))) \\ upright(\"VO\")(upright(\"rest\")), upright(\"lhs\") arrow.r.double upright(\"PassThroughArgumentsHelper\")(i, upright(\"EcxVo\")(upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"rest\"), upright(\"t3.erase\")()))))) quad upright(\"if\") quad i == upright(\"_t1.a0\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"_f3\") < i", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rest\") $]) $] \\ upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rest\") $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rest\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"PassThroughArgumentsHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ i $], upright(\"EcxVo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"rest\"), upright(\"t3.erase\")())) $])) $]) quad upright(\"if\") quad i == upright(\"_t1.a0\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"_f3\") < i" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7401_5_MyTxEggccExtraction_add_rule__r0136__b5a70e42be39ac37", + "display_name": "r0136", + "rule_name": "r0136", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 231647, + "line": 7401, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 231647, + "end": 231803 + }, + "pattern_range": { + "start": 231693, + "end": 231704 + }, + "action_range": { + "start": 231706, + "end": 231802 + } + }, + "nodes": [ + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 114019, + "end": 114064 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "lhs: EcxVecOperand", + "range": { + "start": 114069, + "end": 114107 + }, + "inputs": [] + }, + { + "id": "rest", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "rest: EcxVecOperandBase", + "range": { + "start": 114112, + "end": 114155 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t2: EcxVO", + "range": { + "start": 114160, + "end": 114190 + }, + "inputs": [ + "rest" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxPassThroughArgumentsHelper", + "label": "_t1: EcxPassThroughArgumentsHelper", + "range": { + "start": 114195, + "end": 114248 + }, + "inputs": [ + "_t2" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t4: EcxVO", + "range": { + "start": 114253, + "end": 114283 + }, + "inputs": [ + "rest" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxVecOperand_length", + "label": "_f3: EcxVecOperand_length", + "range": { + "start": 114288, + "end": 114332 + }, + "inputs": [ + "_t4" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "rest", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "rest", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "_t4", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "i", + "lhs", + "rest", + "_t1", + "_t2", + "_f3", + "_t4" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_t1.handle_a0())", + "semantic_text": "i == _t1.a0", + "referenced_vars": [ + "_t1", + "i" + ], + "range": { + "start": 114534, + "end": 114536 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 114554, + "end": 114556 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "_f3.handle().eq(&i.handle())", + "semantic_text": "_f3 == i", + "referenced_vars": [ + "_f3", + "i" + ], + "range": { + "start": 114574, + "end": 114576 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@231736:231763", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_vo(pat.rest)", + "semantic_text": null, + "referenced_pat_vars": [ + "rest" + ], + "referenced_action_vars": [], + "range": { + "start": 231736, + "end": 231763 + } + }, + { + "id": "effect_1", + "effect_id": "effect@231773:231795", + "bound_var": null, + "source_text": "ctx.union(pat.lhs, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 231773, + "end": 231795 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0136", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxPassThroughArgumentsHelper", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"rest\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rest\") $]) $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxVecOperand_length", + "plain_source": "upright(\"EcxVecOperand_length\")(upright(\"VO\")(upright(\"rest\")))", + "colored_source": "upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rest\") $]) $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"rest\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rest\") $]) $]" + } + ], + "side_conditions": [ + "i == upright(\"_t1.a0\")", + "upright(\"lhs\") == upright(\"_t1\")", + "upright(\"_f3\") == i" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"EcxVo\")(upright(\"rest\"))", + "colored_source": "upright(\"EcxVo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rest\") $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "lhs", + "label": "lhs: EcxVecOperand", + "plain_source": "upright(\"lhs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"EcxVo\")(upright(\"rest\"))", + "colored_source": "upright(\"EcxVo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rest\") $])" + } + } + ], + "formula_source": { + "plain": "frac(i \\ upright(\"_t1\") \\ upright(\"VO\")(upright(\"rest\")) \\ upright(\"EcxVecOperand_length\")(upright(\"VO\")(upright(\"rest\"))) \\ upright(\"VO\")(upright(\"rest\")), upright(\"lhs\") arrow.r.double upright(\"EcxVo\")(upright(\"rest\"))) quad upright(\"if\") quad i == upright(\"_t1.a0\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"_f3\") == i", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rest\") $]) $] \\ upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rest\") $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rest\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] arrow.r.double upright(\"EcxVo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rest\") $])) quad upright(\"if\") quad i == upright(\"_t1.a0\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"_f3\") == i" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7405_5_MyTxEggccExtraction_add_rule__r0137__bf7d6c9498ce9918", + "display_name": "r0137", + "rule_name": "r0137", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 231809, + "line": 7405, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 231809, + "end": 232235 + }, + "pattern_range": { + "start": 231860, + "end": 231871 + }, + "action_range": { + "start": 231873, + "end": 232234 + } + }, + "nodes": [ + { + "id": "body", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "body: EcxBody", + "range": { + "start": 114759, + "end": 114792 + }, + "inputs": [] + }, + { + "id": "body_len", + "kind": "query", + "dsl_type": "", + "label": "body_len: ", + "range": { + "start": 114797, + "end": 114856 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxBodyToVecOperand", + "label": "_t1: EcxBodyToVecOperand", + "range": { + "start": 114861, + "end": 114905 + }, + "inputs": [ + "body" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "body", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "body", + "body_len", + "_t1" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "body_len.handle().eq(&_t1.handle_a0())", + "semantic_text": "body_len == _t1.a0", + "referenced_vars": [ + "_t1", + "body_len" + ], + "range": { + "start": 115004, + "end": 115006 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@231903:232195", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_body_to_vec_operand_helper(\n 0_i64,\n ctx.devalue(pat.body_len),\n pat.body,\n ctx.intern_container::>(VecContainer::<\n EcxOperand,\n >::new(\n )),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "body", + "body_len" + ], + "referenced_action_vars": [], + "range": { + "start": 231903, + "end": 232195 + } + }, + { + "id": "effect_1", + "effect_id": "effect@232205:232227", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 232205, + "end": 232227 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0137", + "premises": [ + { + "target_id": "body_len", + "label": "body_len: ", + "plain_source": "upright(\"body_len\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body_len\") $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxBodyToVecOperand", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + } + ], + "side_conditions": [ + "upright(\"body_len\") == upright(\"_t1.a0\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "t_1", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ t_1 $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "_t1", + "label": "_t1: EcxBodyToVecOperand", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "t_1", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ t_1 $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"body_len\") \\ upright(\"_t1\"), upright(\"_t1\") arrow.r.double t_1) quad upright(\"if\") quad upright(\"body_len\") == upright(\"_t1.a0\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body_len\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ t_1 $]) quad upright(\"if\") quad upright(\"body_len\") == upright(\"_t1.a0\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7417_5_MyTxEggccExtraction_add_rule__r0138__0fca9087fa7120b2", + "display_name": "r0138", + "rule_name": "r0138", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 232241, + "line": 7417, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 232241, + "end": 232829 + }, + "pattern_range": { + "start": 232287, + "end": 232298 + }, + "action_range": { + "start": 232300, + "end": 232828 + } + }, + "nodes": [ + { + "id": "body", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "body: EcxBody", + "range": { + "start": 115269, + "end": 115302 + }, + "inputs": [] + }, + { + "id": "body_len", + "kind": "query", + "dsl_type": "", + "label": "body_len: ", + "range": { + "start": 115307, + "end": 115366 + }, + "inputs": [] + }, + { + "id": "helper", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "helper: EcxVecOperand", + "range": { + "start": 115371, + "end": 115412 + }, + "inputs": [] + }, + { + "id": "index", + "kind": "query", + "dsl_type": "", + "label": "index: ", + "range": { + "start": 115417, + "end": 115470 + }, + "inputs": [] + }, + { + "id": "so_far", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "so_far: EcxVecOperandBase", + "range": { + "start": 115475, + "end": 115520 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxBodyToVecOperandHelper", + "label": "_t1: EcxBodyToVecOperandHelper", + "range": { + "start": 115525, + "end": 115584 + }, + "inputs": [ + "body", + "so_far" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "body", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "so_far", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "body", + "body_len", + "helper", + "index", + "so_far", + "_t1" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "index.handle().eq(&_t1.handle_a0())", + "semantic_text": "index == _t1.a0", + "referenced_vars": [ + "_t1", + "index" + ], + "range": { + "start": 115865, + "end": 115867 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "body_len.handle().eq(&_t1.handle_a1())", + "semantic_text": "body_len == _t1.a1", + "referenced_vars": [ + "_t1", + "body_len" + ], + "range": { + "start": 115885, + "end": 115887 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "helper.handle().eq(&_t1.handle())", + "semantic_text": "helper == _t1", + "referenced_vars": [ + "_t1", + "helper" + ], + "range": { + "start": 115905, + "end": 115907 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "index.handle().lt(&body_len.handle())", + "semantic_text": "index < body_len", + "referenced_vars": [ + "body_len", + "index" + ], + "range": { + "start": 115925, + "end": 115927 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@232330:232386", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_project(ctx.devalue(pat.index), pat.body)", + "semantic_text": null, + "referenced_pat_vars": [ + "body", + "index" + ], + "referenced_action_vars": [], + "range": { + "start": 232330, + "end": 232386 + } + }, + { + "id": "effect_1", + "effect_id": "effect@232405:232786", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_body_to_vec_operand_helper(\n (ctx.devalue(pat.index) + 1_i64),\n ctx.devalue(pat.body_len),\n pat.body,\n ctx.intern_container::>(vec_push::<\n EcxOperand,\n >(\n &*ctx.devalue(pat.so_far),\n t2.erase(),\n )),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "body", + "body_len", + "index", + "so_far" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 232405, + "end": 232786 + } + }, + { + "id": "effect_2", + "effect_id": "effect@232796:232821", + "bound_var": null, + "source_text": "ctx.union(pat.helper, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "helper" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 232796, + "end": 232821 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0138", + "premises": [ + { + "target_id": "body_len", + "label": "body_len: ", + "plain_source": "upright(\"body_len\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body_len\") $]" + }, + { + "target_id": "index", + "label": "index: ", + "plain_source": "upright(\"index\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxBodyToVecOperandHelper", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + } + ], + "side_conditions": [ + "upright(\"index\") == upright(\"_t1.a0\")", + "upright(\"body_len\") == upright(\"_t1.a1\")", + "upright(\"helper\") == upright(\"_t1\")", + "upright(\"index\") < upright(\"body_len\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"Project\")(upright(\"index\"), upright(\"body\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Project\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "t_1", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ t_1 $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "helper", + "label": "helper: EcxVecOperand", + "plain_source": "upright(\"helper\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"helper\") $]" + }, + "to": { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "t_1", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ t_1 $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"body_len\") \\ upright(\"index\") \\ upright(\"_t1\"), upright(\"helper\") arrow.r.double t_1) quad upright(\"if\") quad upright(\"index\") == upright(\"_t1.a0\") \\ upright(\"body_len\") == upright(\"_t1.a1\") \\ upright(\"helper\") == upright(\"_t1\") \\ upright(\"index\") < upright(\"body_len\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body_len\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"helper\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ t_1 $]) quad upright(\"if\") quad upright(\"index\") == upright(\"_t1.a0\") \\ upright(\"body_len\") == upright(\"_t1.a1\") \\ upright(\"helper\") == upright(\"_t1\") \\ upright(\"index\") < upright(\"body_len\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7432_5_MyTxEggccExtraction_add_rule__r0139__6780bfecc6172ff4", + "display_name": "r0139", + "rule_name": "r0139", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 232835, + "line": 7432, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 232835, + "end": 232996 + }, + "pattern_range": { + "start": 232881, + "end": 232892 + }, + "action_range": { + "start": 232894, + "end": 232995 + } + }, + "nodes": [ + { + "id": "body", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "body: EcxBody", + "range": { + "start": 116190, + "end": 116223 + }, + "inputs": [] + }, + { + "id": "body_len", + "kind": "query", + "dsl_type": "", + "label": "body_len: ", + "range": { + "start": 116228, + "end": 116287 + }, + "inputs": [] + }, + { + "id": "helper", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "helper: EcxVecOperand", + "range": { + "start": 116292, + "end": 116333 + }, + "inputs": [] + }, + { + "id": "index", + "kind": "query", + "dsl_type": "", + "label": "index: ", + "range": { + "start": 116338, + "end": 116391 + }, + "inputs": [] + }, + { + "id": "so_far", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "so_far: EcxVecOperandBase", + "range": { + "start": 116396, + "end": 116441 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxBodyToVecOperandHelper", + "label": "_t1: EcxBodyToVecOperandHelper", + "range": { + "start": 116446, + "end": 116505 + }, + "inputs": [ + "body", + "so_far" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "body", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "so_far", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "body", + "body_len", + "helper", + "index", + "so_far", + "_t1" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "index.handle().eq(&_t1.handle_a0())", + "semantic_text": "index == _t1.a0", + "referenced_vars": [ + "_t1", + "index" + ], + "range": { + "start": 116786, + "end": 116788 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "body_len.handle().eq(&_t1.handle_a1())", + "semantic_text": "body_len == _t1.a1", + "referenced_vars": [ + "_t1", + "body_len" + ], + "range": { + "start": 116806, + "end": 116808 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "helper.handle().eq(&_t1.handle())", + "semantic_text": "helper == _t1", + "referenced_vars": [ + "_t1", + "helper" + ], + "range": { + "start": 116826, + "end": 116828 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "index.handle().eq(&body_len.handle())", + "semantic_text": "index == body_len", + "referenced_vars": [ + "body_len", + "index" + ], + "range": { + "start": 116846, + "end": 116848 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@232924:232953", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_vo(pat.so_far)", + "semantic_text": null, + "referenced_pat_vars": [ + "so_far" + ], + "referenced_action_vars": [], + "range": { + "start": 232924, + "end": 232953 + } + }, + { + "id": "effect_1", + "effect_id": "effect@232963:232988", + "bound_var": null, + "source_text": "ctx.union(pat.helper, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "helper" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 232963, + "end": 232988 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0139", + "premises": [ + { + "target_id": "body_len", + "label": "body_len: ", + "plain_source": "upright(\"body_len\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body_len\") $]" + }, + { + "target_id": "index", + "label": "index: ", + "plain_source": "upright(\"index\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxBodyToVecOperandHelper", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + } + ], + "side_conditions": [ + "upright(\"index\") == upright(\"_t1.a0\")", + "upright(\"body_len\") == upright(\"_t1.a1\")", + "upright(\"helper\") == upright(\"_t1\")", + "upright(\"index\") == upright(\"body_len\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"EcxVo\")(upright(\"so_far\"))", + "colored_source": "upright(\"EcxVo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"so_far\") $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "helper", + "label": "helper: EcxVecOperand", + "plain_source": "upright(\"helper\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"helper\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"EcxVo\")(upright(\"so_far\"))", + "colored_source": "upright(\"EcxVo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"so_far\") $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"body_len\") \\ upright(\"index\") \\ upright(\"_t1\"), upright(\"helper\") arrow.r.double upright(\"EcxVo\")(upright(\"so_far\"))) quad upright(\"if\") quad upright(\"index\") == upright(\"_t1.a0\") \\ upright(\"body_len\") == upright(\"_t1.a1\") \\ upright(\"helper\") == upright(\"_t1\") \\ upright(\"index\") == upright(\"body_len\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body_len\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"helper\") $] arrow.r.double upright(\"EcxVo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"so_far\") $])) quad upright(\"if\") quad upright(\"index\") == upright(\"_t1.a0\") \\ upright(\"body_len\") == upright(\"_t1.a1\") \\ upright(\"helper\") == upright(\"_t1\") \\ upright(\"index\") == upright(\"body_len\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7436_5_MyTxEggccExtraction_add_rule__r0140__ee3e61d459a6687c", + "display_name": "r0140", + "rule_name": "r0140", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 233002, + "line": 7436, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 233002, + "end": 233355 + }, + "pattern_range": { + "start": 233053, + "end": 233064 + }, + "action_range": { + "start": 233066, + "end": 233354 + } + }, + "nodes": [ + { + "id": "gamma", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "gamma: EcxBody", + "range": { + "start": 117197, + "end": 117231 + }, + "inputs": [] + }, + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 117236, + "end": 117277 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperandBase", + "label": "outputs: EcxVecVecOperandBase", + "range": { + "start": 117282, + "end": 117331 + }, + "inputs": [] + }, + { + "id": "_t5", + "kind": "query", + "dsl_type": "EcxBoolT", + "label": "_t5: EcxBoolT", + "range": { + "start": 117336, + "end": 117364 + }, + "inputs": [] + }, + { + "id": "_t6", + "kind": "query", + "dsl_type": "Ecxkw_const", + "label": "_t6: Ecxkw_const", + "range": { + "start": 117369, + "end": 117400 + }, + "inputs": [] + }, + { + "id": "_t7", + "kind": "query", + "dsl_type": "EcxBool", + "label": "_t7: EcxBool", + "range": { + "start": 117405, + "end": 117432 + }, + "inputs": [] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxConst", + "label": "_t4: EcxConst", + "range": { + "start": 117437, + "end": 117481 + }, + "inputs": [ + "_t5", + "_t6", + "_t7" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t3: EcxPureOp", + "range": { + "start": 117486, + "end": 117519 + }, + "inputs": [ + "_t4" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t2: EcxNode", + "range": { + "start": 117524, + "end": 117555 + }, + "inputs": [ + "_t3" + ] + }, + { + "id": "_t8", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t8: EcxVVO", + "range": { + "start": 117560, + "end": 117594 + }, + "inputs": [ + "outputs" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxGamma", + "label": "_t1: EcxGamma", + "range": { + "start": 117599, + "end": 117646 + }, + "inputs": [ + "_t2", + "inputs", + "_t8" + ] + } + ], + "edges": [ + { + "from": "_t4", + "to": "_t5", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "_t6", + "kind": "operand", + "index": 1 + }, + { + "from": "_t4", + "to": "_t7", + "kind": "operand", + "index": 2 + }, + { + "from": "_t3", + "to": "_t4", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "_t3", + "kind": "operand", + "index": 0 + }, + { + "from": "_t8", + "to": "outputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "_t8", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "gamma", + "inputs", + "outputs", + "_t1", + "_t2", + "_t3", + "_t4", + "_t5", + "_t6", + "_t7", + "_t8" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "_t7.handle_a0().eq(&(true))", + "semantic_text": "_t7.a0 == true", + "referenced_vars": [ + "_t7" + ], + "range": { + "start": 117844, + "end": 117846 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "gamma.handle().eq(&_t1.handle())", + "semantic_text": "gamma == _t1", + "referenced_vars": [ + "_t1", + "gamma" + ], + "range": { + "start": 117860, + "end": 117862 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@233096:233127", + "bound_var": "t4", + "source_text": "ctx.insert_ecx_vvo(pat.outputs)", + "semantic_text": null, + "referenced_pat_vars": [ + "outputs" + ], + "referenced_action_vars": [], + "range": { + "start": 233096, + "end": 233127 + } + }, + { + "id": "effect_1", + "effect_id": "effect@233146:233191", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_vec_vec_operand_get(t4, 1_i64)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t4" + ], + "range": { + "start": 233146, + "end": 233191 + } + }, + { + "id": "effect_2", + "effect_id": "effect@233210:233262", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_vec_operand_all(t3, pat.inputs)", + "semantic_text": null, + "referenced_pat_vars": [ + "inputs" + ], + "referenced_action_vars": [ + "t3" + ], + "range": { + "start": 233210, + "end": 233262 + } + }, + { + "id": "effect_3", + "effect_id": "effect@233281:233313", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_operand_group(t2)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 233281, + "end": 233313 + } + }, + { + "id": "effect_4", + "effect_id": "effect@233323:233347", + "bound_var": null, + "source_text": "ctx.union(pat.gamma, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "gamma" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 233323, + "end": 233347 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0140", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxGamma", + "plain_source": "upright(\"Gamma\")((upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"_t5\"), upright(\"_t6\"), upright(\"_t7\"))))))), upright(\"inputs\"), (upright(\"VVO\")(upright(\"outputs\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]) $])) $])) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxNode", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"_t5\"), upright(\"_t6\"), upright(\"_t7\"))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]) $])) $])) $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxPureOp", + "plain_source": "upright(\"PureOp\")((upright(\"Const\")(upright(\"_t5\"), upright(\"_t6\"), upright(\"_t7\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]) $])) $]" + }, + { + "target_id": "_t4", + "label": "_t4: EcxConst", + "plain_source": "upright(\"Const\")(upright(\"_t5\"), upright(\"_t6\"), upright(\"_t7\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]) $]" + }, + { + "target_id": "_t5", + "label": "_t5: EcxBoolT", + "plain_source": "upright(\"BoolT\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $]" + }, + { + "target_id": "_t6", + "label": "_t6: Ecxkw_const", + "plain_source": "upright(\"kw_const\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $]" + }, + { + "target_id": "_t7", + "label": "_t7: EcxBool", + "plain_source": "upright(\"_t7\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]" + }, + { + "target_id": "_t8", + "label": "_t8: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + ], + "side_conditions": [ + "upright(\"_t7.a0\") == upright(\"true\")", + "upright(\"gamma\") == upright(\"_t1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t4", + "plain_source": "upright(\"EcxVvo\")(upright(\"outputs\"))", + "colored_source": "upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $])" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(upright(\"outputs\")), 1)", + "colored_source": "upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 1 $])" + }, + { + "target_id": "effect:effect_2", + "label": "t2", + "plain_source": "upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(upright(\"outputs\")), 1), upright(\"inputs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $]" + }, + { + "target_id": "effect:effect_3", + "label": "t1", + "plain_source": "upright(\"OperandGroup\")((upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(upright(\"outputs\")), 1), upright(\"inputs\"))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_4", + "from": { + "target_id": "gamma", + "label": "gamma: EcxBody", + "plain_source": "upright(\"gamma\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"gamma\") $]" + }, + "to": { + "target_id": "effect:effect_3", + "label": "t1", + "plain_source": "upright(\"OperandGroup\")((upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(upright(\"outputs\")), 1), upright(\"inputs\"))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"Gamma\")((upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"_t5\"), upright(\"_t6\"), upright(\"_t7\"))))))), upright(\"inputs\"), (upright(\"VVO\")(upright(\"outputs\")))) \\ upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"_t5\"), upright(\"_t6\"), upright(\"_t7\")))))) \\ upright(\"PureOp\")((upright(\"Const\")(upright(\"_t5\"), upright(\"_t6\"), upright(\"_t7\")))) \\ upright(\"Const\")(upright(\"_t5\"), upright(\"_t6\"), upright(\"_t7\")) \\ upright(\"BoolT\") \\ upright(\"kw_const\") \\ upright(\"_t7\") \\ upright(\"VVO\")(upright(\"outputs\")), upright(\"gamma\") arrow.r.double upright(\"OperandGroup\")((upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(upright(\"outputs\")), 1), upright(\"inputs\"))))) quad upright(\"if\") quad upright(\"_t7.a0\") == upright(\"true\") \\ upright(\"gamma\") == upright(\"_t1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]) $])) $])) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"gamma\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $])) $]) quad upright(\"if\") quad upright(\"_t7.a0\") == upright(\"true\") \\ upright(\"gamma\") == upright(\"_t1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7443_5_MyTxEggccExtraction_add_rule__r0141__60430cfd3273a1cb", + "display_name": "r0141", + "rule_name": "r0141", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 233361, + "line": 7443, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 233361, + "end": 233714 + }, + "pattern_range": { + "start": 233412, + "end": 233423 + }, + "action_range": { + "start": 233425, + "end": 233713 + } + }, + "nodes": [ + { + "id": "gamma", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "gamma: EcxBody", + "range": { + "start": 118211, + "end": 118245 + }, + "inputs": [] + }, + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 118250, + "end": 118291 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperandBase", + "label": "outputs: EcxVecVecOperandBase", + "range": { + "start": 118296, + "end": 118345 + }, + "inputs": [] + }, + { + "id": "_t5", + "kind": "query", + "dsl_type": "EcxBoolT", + "label": "_t5: EcxBoolT", + "range": { + "start": 118350, + "end": 118378 + }, + "inputs": [] + }, + { + "id": "_t6", + "kind": "query", + "dsl_type": "Ecxkw_const", + "label": "_t6: Ecxkw_const", + "range": { + "start": 118383, + "end": 118414 + }, + "inputs": [] + }, + { + "id": "_t7", + "kind": "query", + "dsl_type": "EcxBool", + "label": "_t7: EcxBool", + "range": { + "start": 118419, + "end": 118446 + }, + "inputs": [] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxConst", + "label": "_t4: EcxConst", + "range": { + "start": 118451, + "end": 118495 + }, + "inputs": [ + "_t5", + "_t6", + "_t7" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t3: EcxPureOp", + "range": { + "start": 118500, + "end": 118533 + }, + "inputs": [ + "_t4" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t2: EcxNode", + "range": { + "start": 118538, + "end": 118569 + }, + "inputs": [ + "_t3" + ] + }, + { + "id": "_t8", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t8: EcxVVO", + "range": { + "start": 118574, + "end": 118608 + }, + "inputs": [ + "outputs" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxGamma", + "label": "_t1: EcxGamma", + "range": { + "start": 118613, + "end": 118660 + }, + "inputs": [ + "_t2", + "inputs", + "_t8" + ] + } + ], + "edges": [ + { + "from": "_t4", + "to": "_t5", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "_t6", + "kind": "operand", + "index": 1 + }, + { + "from": "_t4", + "to": "_t7", + "kind": "operand", + "index": 2 + }, + { + "from": "_t3", + "to": "_t4", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "_t3", + "kind": "operand", + "index": 0 + }, + { + "from": "_t8", + "to": "outputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "_t8", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "gamma", + "inputs", + "outputs", + "_t1", + "_t2", + "_t3", + "_t4", + "_t5", + "_t6", + "_t7", + "_t8" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "_t7.handle_a0().eq(&(false))", + "semantic_text": "_t7.a0 == false", + "referenced_vars": [ + "_t7" + ], + "range": { + "start": 118859, + "end": 118861 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "gamma.handle().eq(&_t1.handle())", + "semantic_text": "gamma == _t1", + "referenced_vars": [ + "_t1", + "gamma" + ], + "range": { + "start": 118875, + "end": 118877 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@233455:233486", + "bound_var": "t4", + "source_text": "ctx.insert_ecx_vvo(pat.outputs)", + "semantic_text": null, + "referenced_pat_vars": [ + "outputs" + ], + "referenced_action_vars": [], + "range": { + "start": 233455, + "end": 233486 + } + }, + { + "id": "effect_1", + "effect_id": "effect@233505:233550", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_vec_vec_operand_get(t4, 0_i64)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t4" + ], + "range": { + "start": 233505, + "end": 233550 + } + }, + { + "id": "effect_2", + "effect_id": "effect@233569:233621", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_vec_operand_all(t3, pat.inputs)", + "semantic_text": null, + "referenced_pat_vars": [ + "inputs" + ], + "referenced_action_vars": [ + "t3" + ], + "range": { + "start": 233569, + "end": 233621 + } + }, + { + "id": "effect_3", + "effect_id": "effect@233640:233672", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_operand_group(t2)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 233640, + "end": 233672 + } + }, + { + "id": "effect_4", + "effect_id": "effect@233682:233706", + "bound_var": null, + "source_text": "ctx.union(pat.gamma, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "gamma" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 233682, + "end": 233706 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0141", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxGamma", + "plain_source": "upright(\"Gamma\")((upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"_t5\"), upright(\"_t6\"), upright(\"_t7\"))))))), upright(\"inputs\"), (upright(\"VVO\")(upright(\"outputs\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]) $])) $])) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxNode", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"_t5\"), upright(\"_t6\"), upright(\"_t7\"))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]) $])) $])) $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxPureOp", + "plain_source": "upright(\"PureOp\")((upright(\"Const\")(upright(\"_t5\"), upright(\"_t6\"), upright(\"_t7\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]) $])) $]" + }, + { + "target_id": "_t4", + "label": "_t4: EcxConst", + "plain_source": "upright(\"Const\")(upright(\"_t5\"), upright(\"_t6\"), upright(\"_t7\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]) $]" + }, + { + "target_id": "_t5", + "label": "_t5: EcxBoolT", + "plain_source": "upright(\"BoolT\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $]" + }, + { + "target_id": "_t6", + "label": "_t6: Ecxkw_const", + "plain_source": "upright(\"kw_const\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $]" + }, + { + "target_id": "_t7", + "label": "_t7: EcxBool", + "plain_source": "upright(\"_t7\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]" + }, + { + "target_id": "_t8", + "label": "_t8: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + ], + "side_conditions": [ + "upright(\"_t7.a0\") == upright(\"false\")", + "upright(\"gamma\") == upright(\"_t1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t4", + "plain_source": "upright(\"EcxVvo\")(upright(\"outputs\"))", + "colored_source": "upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $])" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(upright(\"outputs\")), 0)", + "colored_source": "upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 0 $])" + }, + { + "target_id": "effect:effect_2", + "label": "t2", + "plain_source": "upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(upright(\"outputs\")), 0), upright(\"inputs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $]" + }, + { + "target_id": "effect:effect_3", + "label": "t1", + "plain_source": "upright(\"OperandGroup\")((upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(upright(\"outputs\")), 0), upright(\"inputs\"))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_4", + "from": { + "target_id": "gamma", + "label": "gamma: EcxBody", + "plain_source": "upright(\"gamma\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"gamma\") $]" + }, + "to": { + "target_id": "effect:effect_3", + "label": "t1", + "plain_source": "upright(\"OperandGroup\")((upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(upright(\"outputs\")), 0), upright(\"inputs\"))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"Gamma\")((upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"_t5\"), upright(\"_t6\"), upright(\"_t7\"))))))), upright(\"inputs\"), (upright(\"VVO\")(upright(\"outputs\")))) \\ upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"_t5\"), upright(\"_t6\"), upright(\"_t7\")))))) \\ upright(\"PureOp\")((upright(\"Const\")(upright(\"_t5\"), upright(\"_t6\"), upright(\"_t7\")))) \\ upright(\"Const\")(upright(\"_t5\"), upright(\"_t6\"), upright(\"_t7\")) \\ upright(\"BoolT\") \\ upright(\"kw_const\") \\ upright(\"_t7\") \\ upright(\"VVO\")(upright(\"outputs\")), upright(\"gamma\") arrow.r.double upright(\"OperandGroup\")((upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(upright(\"outputs\")), 0), upright(\"inputs\"))))) quad upright(\"if\") quad upright(\"_t7.a0\") == upright(\"false\") \\ upright(\"gamma\") == upright(\"_t1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]) $])) $])) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"gamma\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $])) $]) quad upright(\"if\") quad upright(\"_t7.a0\") == upright(\"false\") \\ upright(\"gamma\") == upright(\"_t1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7450_5_MyTxEggccExtraction_add_rule__r0142__8cb6cfab3e6cf7ee", + "display_name": "r0142", + "rule_name": "r0142", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 233720, + "line": 7450, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 233720, + "end": 234093 + }, + "pattern_range": { + "start": 233771, + "end": 233782 + }, + "action_range": { + "start": 233784, + "end": 234092 + } + }, + "nodes": [ + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "inputs: EcxVecOperandBase", + "range": { + "start": 119242, + "end": 119287 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "outputs: EcxVecOperandBase", + "range": { + "start": 119292, + "end": 119338 + }, + "inputs": [] + }, + { + "id": "theta", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "theta: EcxBody", + "range": { + "start": 119343, + "end": 119377 + }, + "inputs": [] + }, + { + "id": "_t5", + "kind": "query", + "dsl_type": "EcxBoolT", + "label": "_t5: EcxBoolT", + "range": { + "start": 119382, + "end": 119410 + }, + "inputs": [] + }, + { + "id": "_t6", + "kind": "query", + "dsl_type": "Ecxkw_const", + "label": "_t6: Ecxkw_const", + "range": { + "start": 119415, + "end": 119446 + }, + "inputs": [] + }, + { + "id": "_t7", + "kind": "query", + "dsl_type": "EcxBool", + "label": "_t7: EcxBool", + "range": { + "start": 119451, + "end": 119478 + }, + "inputs": [] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxConst", + "label": "_t4: EcxConst", + "range": { + "start": 119483, + "end": 119527 + }, + "inputs": [ + "_t5", + "_t6", + "_t7" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t3: EcxPureOp", + "range": { + "start": 119532, + "end": 119565 + }, + "inputs": [ + "_t4" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t2: EcxNode", + "range": { + "start": 119570, + "end": 119601 + }, + "inputs": [ + "_t3" + ] + }, + { + "id": "_t8", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t8: EcxVO", + "range": { + "start": 119606, + "end": 119638 + }, + "inputs": [ + "inputs" + ] + }, + { + "id": "_t9", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t9: EcxVO", + "range": { + "start": 119643, + "end": 119676 + }, + "inputs": [ + "outputs" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxTheta", + "label": "_t1: EcxTheta", + "range": { + "start": 119681, + "end": 119725 + }, + "inputs": [ + "_t2", + "_t8", + "_t9" + ] + } + ], + "edges": [ + { + "from": "_t4", + "to": "_t5", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "_t6", + "kind": "operand", + "index": 1 + }, + { + "from": "_t4", + "to": "_t7", + "kind": "operand", + "index": 2 + }, + { + "from": "_t3", + "to": "_t4", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "_t3", + "kind": "operand", + "index": 0 + }, + { + "from": "_t8", + "to": "inputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t9", + "to": "outputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t8", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "_t9", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "inputs", + "outputs", + "theta", + "_t1", + "_t2", + "_t3", + "_t4", + "_t5", + "_t6", + "_t7", + "_t8", + "_t9" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "_t7.handle_a0().eq(&(false))", + "semantic_text": "_t7.a0 == false", + "referenced_vars": [ + "_t7" + ], + "range": { + "start": 119929, + "end": 119931 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "theta.handle().eq(&_t1.handle())", + "semantic_text": "theta == _t1", + "referenced_vars": [ + "_t1", + "theta" + ], + "range": { + "start": 119945, + "end": 119947 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@233814:233844", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_vo(pat.outputs)", + "semantic_text": null, + "referenced_pat_vars": [ + "outputs" + ], + "referenced_action_vars": [], + "range": { + "start": 233814, + "end": 233844 + } + }, + { + "id": "effect_1", + "effect_id": "effect@233863:233892", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_vo(pat.inputs)", + "semantic_text": null, + "referenced_pat_vars": [ + "inputs" + ], + "referenced_action_vars": [], + "range": { + "start": 233863, + "end": 233892 + } + }, + { + "id": "effect_2", + "effect_id": "effect@233911:233955", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_subst_vec_operand_all(t2, t3)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 233911, + "end": 233955 + } + }, + { + "id": "effect_3", + "effect_id": "effect@234007:234051", + "bound_var": "t4", + "source_text": "ctx.insert_ecx_operand_group(after_one_iter)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 234007, + "end": 234051 + } + }, + { + "id": "effect_4", + "effect_id": "effect@234061:234085", + "bound_var": null, + "source_text": "ctx.union(pat.theta, t4)", + "semantic_text": null, + "referenced_pat_vars": [ + "theta" + ], + "referenced_action_vars": [ + "t4" + ], + "range": { + "start": 234061, + "end": 234085 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0142", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxTheta", + "plain_source": "upright(\"Theta\")((upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"_t5\"), upright(\"_t6\"), upright(\"_t7\"))))))), (upright(\"VO\")(upright(\"inputs\"))), (upright(\"VO\")(upright(\"outputs\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]) $])) $])) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxNode", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"_t5\"), upright(\"_t6\"), upright(\"_t7\"))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]) $])) $])) $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxPureOp", + "plain_source": "upright(\"PureOp\")((upright(\"Const\")(upright(\"_t5\"), upright(\"_t6\"), upright(\"_t7\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]) $])) $]" + }, + { + "target_id": "_t4", + "label": "_t4: EcxConst", + "plain_source": "upright(\"Const\")(upright(\"_t5\"), upright(\"_t6\"), upright(\"_t7\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]) $]" + }, + { + "target_id": "_t5", + "label": "_t5: EcxBoolT", + "plain_source": "upright(\"BoolT\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $]" + }, + { + "target_id": "_t6", + "label": "_t6: Ecxkw_const", + "plain_source": "upright(\"kw_const\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $]" + }, + { + "target_id": "_t7", + "label": "_t7: EcxBool", + "plain_source": "upright(\"_t7\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]" + }, + { + "target_id": "_t8", + "label": "_t8: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"inputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $]" + }, + { + "target_id": "_t9", + "label": "_t9: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + ], + "side_conditions": [ + "upright(\"_t7.a0\") == upright(\"false\")", + "upright(\"theta\") == upright(\"_t1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_3", + "label": "t4", + "plain_source": "upright(\"OperandGroup\")(upright(\"after_one_iter\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"after_one_iter\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_4", + "from": { + "target_id": "theta", + "label": "theta: EcxBody", + "plain_source": "upright(\"theta\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"theta\") $]" + }, + "to": { + "target_id": "effect:effect_3", + "label": "t4", + "plain_source": "upright(\"OperandGroup\")(upright(\"after_one_iter\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"after_one_iter\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"Theta\")((upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"_t5\"), upright(\"_t6\"), upright(\"_t7\"))))))), (upright(\"VO\")(upright(\"inputs\"))), (upright(\"VO\")(upright(\"outputs\")))) \\ upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"_t5\"), upright(\"_t6\"), upright(\"_t7\")))))) \\ upright(\"PureOp\")((upright(\"Const\")(upright(\"_t5\"), upright(\"_t6\"), upright(\"_t7\")))) \\ upright(\"Const\")(upright(\"_t5\"), upright(\"_t6\"), upright(\"_t7\")) \\ upright(\"BoolT\") \\ upright(\"kw_const\") \\ upright(\"_t7\") \\ upright(\"VO\")(upright(\"inputs\")) \\ upright(\"VO\")(upright(\"outputs\")), upright(\"theta\") arrow.r.double upright(\"OperandGroup\")(upright(\"after_one_iter\"))) quad upright(\"if\") quad upright(\"_t7.a0\") == upright(\"false\") \\ upright(\"theta\") == upright(\"_t1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]) $])) $])) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"theta\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"after_one_iter\") $]) $]) quad upright(\"if\") quad upright(\"_t7.a0\") == upright(\"false\") \\ upright(\"theta\") == upright(\"_t1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7458_5_MyTxEggccExtraction_add_rule__r0143__ebbd34cb475043d9", + "display_name": "r0143", + "rule_name": "r0143", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 234099, + "line": 7458, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 234099, + "end": 234403 + }, + "pattern_range": { + "start": 234150, + "end": 234161 + }, + "action_range": { + "start": 234163, + "end": 234402 + } + }, + "nodes": [ + { + "id": "n1", + "kind": "query", + "dsl_type": "", + "label": "n1: ", + "range": { + "start": 120362, + "end": 120409 + }, + "inputs": [] + }, + { + "id": "n2", + "kind": "query", + "dsl_type": "", + "label": "n2: ", + "range": { + "start": 120414, + "end": 120461 + }, + "inputs": [] + }, + { + "id": "output_type", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "output_type: EcxType", + "range": { + "start": 120466, + "end": 120506 + }, + "inputs": [] + }, + { + "id": "ty2", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty2: EcxType", + "range": { + "start": 120511, + "end": 120543 + }, + "inputs": [] + }, + { + "id": "ty3", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty3: EcxType", + "range": { + "start": 120548, + "end": 120580 + }, + "inputs": [] + }, + { + "id": "_t5", + "kind": "query", + "dsl_type": "Ecxkw_const", + "label": "_t5: Ecxkw_const", + "range": { + "start": 120585, + "end": 120616 + }, + "inputs": [] + }, + { + "id": "_t6", + "kind": "query", + "dsl_type": "EcxNum", + "label": "_t6: EcxNum", + "range": { + "start": 120621, + "end": 120647 + }, + "inputs": [] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxConst", + "label": "_t4: EcxConst", + "range": { + "start": 120652, + "end": 120696 + }, + "inputs": [ + "ty2", + "_t5", + "_t6" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t3: EcxPureOp", + "range": { + "start": 120701, + "end": 120734 + }, + "inputs": [ + "_t4" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t2: EcxNode", + "range": { + "start": 120739, + "end": 120770 + }, + "inputs": [ + "_t3" + ] + }, + { + "id": "_t10", + "kind": "query", + "dsl_type": "Ecxkw_const", + "label": "_t10: Ecxkw_const", + "range": { + "start": 120775, + "end": 120807 + }, + "inputs": [] + }, + { + "id": "_t11", + "kind": "query", + "dsl_type": "EcxNum", + "label": "_t11: EcxNum", + "range": { + "start": 120812, + "end": 120839 + }, + "inputs": [] + }, + { + "id": "_t9", + "kind": "query", + "dsl_type": "EcxConst", + "label": "_t9: EcxConst", + "range": { + "start": 120844, + "end": 120890 + }, + "inputs": [ + "ty3", + "_t10", + "_t11" + ] + }, + { + "id": "_t8", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t8: EcxPureOp", + "range": { + "start": 120895, + "end": 120928 + }, + "inputs": [ + "_t9" + ] + }, + { + "id": "_t7", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t7: EcxNode", + "range": { + "start": 120933, + "end": 120964 + }, + "inputs": [ + "_t8" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "Ecxbadd", + "label": "_t1: Ecxbadd", + "range": { + "start": 120969, + "end": 121020 + }, + "inputs": [ + "output_type", + "_t2", + "_t7" + ] + } + ], + "edges": [ + { + "from": "_t4", + "to": "ty2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "_t5", + "kind": "operand", + "index": 1 + }, + { + "from": "_t4", + "to": "_t6", + "kind": "operand", + "index": 2 + }, + { + "from": "_t3", + "to": "_t4", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "_t3", + "kind": "operand", + "index": 0 + }, + { + "from": "_t9", + "to": "ty3", + "kind": "operand", + "index": 0 + }, + { + "from": "_t9", + "to": "_t10", + "kind": "operand", + "index": 1 + }, + { + "from": "_t9", + "to": "_t11", + "kind": "operand", + "index": 2 + }, + { + "from": "_t8", + "to": "_t9", + "kind": "operand", + "index": 0 + }, + { + "from": "_t7", + "to": "_t8", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "output_type", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "_t7", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "n1", + "n2", + "output_type", + "ty2", + "ty3", + "_t1", + "_t2", + "_t3", + "_t4", + "_t5", + "_t6", + "_t7", + "_t8", + "_t9", + "_t10", + "_t11" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "n1.handle().eq(&_t6.handle_a0())", + "semantic_text": "n1 == _t6.a0", + "referenced_vars": [ + "_t6", + "n1" + ], + "range": { + "start": 121368, + "end": 121370 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "n2.handle().eq(&_t11.handle_a0())", + "semantic_text": "n2 == _t11.a0", + "referenced_vars": [ + "_t11", + "n2" + ], + "range": { + "start": 121384, + "end": 121386 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@234193:234217", + "bound_var": "t2", + "source_text": "ctx.insert_ecxkw_const()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 234193, + "end": 234217 + } + }, + { + "id": "effect_1", + "effect_id": "effect@234236:234299", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_num((ctx.devalue(pat.n1) + ctx.devalue(pat.n2)))", + "semantic_text": null, + "referenced_pat_vars": [ + "n1", + "n2" + ], + "referenced_action_vars": [], + "range": { + "start": 234236, + "end": 234299 + } + }, + { + "id": "effect_2", + "effect_id": "effect@234318:234363", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_const(pat.output_type, t2, t3)", + "semantic_text": null, + "referenced_pat_vars": [ + "output_type" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 234318, + "end": 234363 + } + }, + { + "id": "effect_3", + "effect_id": "effect@234373:234395", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 234373, + "end": 234395 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0143", + "premises": [ + { + "target_id": "n1", + "label": "n1: ", + "plain_source": "n_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ n_1 $]" + }, + { + "target_id": "n2", + "label": "n2: ", + "plain_source": "n_2", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ n_2 $]" + }, + { + "target_id": "_t1", + "label": "_t1: Ecxbadd", + "plain_source": "upright(\"badd\")(upright(\"output_type\"), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))))), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\"))))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $])) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxNode", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxPureOp", + "plain_source": "upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $]" + }, + { + "target_id": "_t4", + "label": "_t4: EcxConst", + "plain_source": "upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $]" + }, + { + "target_id": "_t5", + "label": "_t5: Ecxkw_const", + "plain_source": "upright(\"kw_const\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $]" + }, + { + "target_id": "_t6", + "label": "_t6: EcxNum", + "plain_source": "upright(\"_t6\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]" + }, + { + "target_id": "_t7", + "label": "_t7: EcxNode", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\"))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $]" + }, + { + "target_id": "_t8", + "label": "_t8: EcxPureOp", + "plain_source": "upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $]" + }, + { + "target_id": "_t9", + "label": "_t9: EcxConst", + "plain_source": "upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $]" + }, + { + "target_id": "_t10", + "label": "_t10: Ecxkw_const", + "plain_source": "upright(\"kw_const\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $]" + }, + { + "target_id": "_t11", + "label": "_t11: EcxNum", + "plain_source": "upright(\"_t11\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]" + } + ], + "side_conditions": [ + "n_1 == upright(\"_t6.a0\")", + "n_2 == upright(\"_t11.a0\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"EcxkwConst\")()", + "colored_source": "upright(\"EcxkwConst\")()" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"Num\")(n_1 + n_2)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Num\")(#text(fill: rgb(\"#B86A5B\"))[$ n_1 + n_2 $]) $]" + }, + { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"Const\")(upright(\"output_type\"), upright(\"EcxkwConst\")(), (upright(\"Num\")(n_1 + n_2)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], upright(\"EcxkwConst\")(), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Num\")(#text(fill: rgb(\"#B86A5B\"))[$ n_1 + n_2 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_3", + "from": { + "target_id": "_t1", + "label": "_t1: Ecxbadd", + "plain_source": "upright(\"badd\")(upright(\"output_type\"), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))))), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\"))))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $])) $]" + }, + "to": { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"Const\")(upright(\"output_type\"), upright(\"EcxkwConst\")(), (upright(\"Num\")(n_1 + n_2)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], upright(\"EcxkwConst\")(), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Num\")(#text(fill: rgb(\"#B86A5B\"))[$ n_1 + n_2 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(n_1 \\ n_2 \\ upright(\"badd\")(upright(\"output_type\"), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))))), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\")))))))) \\ upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\")))))) \\ upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\")))) \\ upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\")) \\ upright(\"kw_const\") \\ upright(\"_t6\") \\ upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\")))))) \\ upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\")))) \\ upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\")) \\ upright(\"kw_const\") \\ upright(\"_t11\"), upright(\"badd\")(upright(\"output_type\"), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))))), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\")))))))) arrow.r.double upright(\"Const\")(upright(\"output_type\"), upright(\"EcxkwConst\")(), (upright(\"Num\")(n_1 + n_2)))) quad upright(\"if\") quad n_1 == upright(\"_t6.a0\") \\ n_2 == upright(\"_t11.a0\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ n_1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ n_2 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $])) $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], upright(\"EcxkwConst\")(), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Num\")(#text(fill: rgb(\"#B86A5B\"))[$ n_1 + n_2 $]) $])) $]) quad upright(\"if\") quad n_1 == upright(\"_t6.a0\") \\ n_2 == upright(\"_t11.a0\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7464_5_MyTxEggccExtraction_add_rule__r0144__ef295ae7dcb966d3", + "display_name": "r0144", + "rule_name": "r0144", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 234409, + "line": 7464, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 234409, + "end": 234713 + }, + "pattern_range": { + "start": 234460, + "end": 234471 + }, + "action_range": { + "start": 234473, + "end": 234712 + } + }, + "nodes": [ + { + "id": "n1", + "kind": "query", + "dsl_type": "", + "label": "n1: ", + "range": { + "start": 121801, + "end": 121848 + }, + "inputs": [] + }, + { + "id": "n2", + "kind": "query", + "dsl_type": "", + "label": "n2: ", + "range": { + "start": 121853, + "end": 121900 + }, + "inputs": [] + }, + { + "id": "output_type", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "output_type: EcxType", + "range": { + "start": 121905, + "end": 121945 + }, + "inputs": [] + }, + { + "id": "ty2", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty2: EcxType", + "range": { + "start": 121950, + "end": 121982 + }, + "inputs": [] + }, + { + "id": "ty3", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty3: EcxType", + "range": { + "start": 121987, + "end": 122019 + }, + "inputs": [] + }, + { + "id": "_t5", + "kind": "query", + "dsl_type": "Ecxkw_const", + "label": "_t5: Ecxkw_const", + "range": { + "start": 122024, + "end": 122055 + }, + "inputs": [] + }, + { + "id": "_t6", + "kind": "query", + "dsl_type": "EcxNum", + "label": "_t6: EcxNum", + "range": { + "start": 122060, + "end": 122086 + }, + "inputs": [] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxConst", + "label": "_t4: EcxConst", + "range": { + "start": 122091, + "end": 122135 + }, + "inputs": [ + "ty2", + "_t5", + "_t6" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t3: EcxPureOp", + "range": { + "start": 122140, + "end": 122173 + }, + "inputs": [ + "_t4" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t2: EcxNode", + "range": { + "start": 122178, + "end": 122209 + }, + "inputs": [ + "_t3" + ] + }, + { + "id": "_t10", + "kind": "query", + "dsl_type": "Ecxkw_const", + "label": "_t10: Ecxkw_const", + "range": { + "start": 122214, + "end": 122246 + }, + "inputs": [] + }, + { + "id": "_t11", + "kind": "query", + "dsl_type": "EcxNum", + "label": "_t11: EcxNum", + "range": { + "start": 122251, + "end": 122278 + }, + "inputs": [] + }, + { + "id": "_t9", + "kind": "query", + "dsl_type": "EcxConst", + "label": "_t9: EcxConst", + "range": { + "start": 122283, + "end": 122329 + }, + "inputs": [ + "ty3", + "_t10", + "_t11" + ] + }, + { + "id": "_t8", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t8: EcxPureOp", + "range": { + "start": 122334, + "end": 122367 + }, + "inputs": [ + "_t9" + ] + }, + { + "id": "_t7", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t7: EcxNode", + "range": { + "start": 122372, + "end": 122403 + }, + "inputs": [ + "_t8" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "Ecxbsub", + "label": "_t1: Ecxbsub", + "range": { + "start": 122408, + "end": 122459 + }, + "inputs": [ + "output_type", + "_t2", + "_t7" + ] + } + ], + "edges": [ + { + "from": "_t4", + "to": "ty2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "_t5", + "kind": "operand", + "index": 1 + }, + { + "from": "_t4", + "to": "_t6", + "kind": "operand", + "index": 2 + }, + { + "from": "_t3", + "to": "_t4", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "_t3", + "kind": "operand", + "index": 0 + }, + { + "from": "_t9", + "to": "ty3", + "kind": "operand", + "index": 0 + }, + { + "from": "_t9", + "to": "_t10", + "kind": "operand", + "index": 1 + }, + { + "from": "_t9", + "to": "_t11", + "kind": "operand", + "index": 2 + }, + { + "from": "_t8", + "to": "_t9", + "kind": "operand", + "index": 0 + }, + { + "from": "_t7", + "to": "_t8", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "output_type", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "_t7", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "n1", + "n2", + "output_type", + "ty2", + "ty3", + "_t1", + "_t2", + "_t3", + "_t4", + "_t5", + "_t6", + "_t7", + "_t8", + "_t9", + "_t10", + "_t11" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "n1.handle().eq(&_t6.handle_a0())", + "semantic_text": "n1 == _t6.a0", + "referenced_vars": [ + "_t6", + "n1" + ], + "range": { + "start": 122807, + "end": 122809 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "n2.handle().eq(&_t11.handle_a0())", + "semantic_text": "n2 == _t11.a0", + "referenced_vars": [ + "_t11", + "n2" + ], + "range": { + "start": 122823, + "end": 122825 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@234503:234527", + "bound_var": "t2", + "source_text": "ctx.insert_ecxkw_const()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 234503, + "end": 234527 + } + }, + { + "id": "effect_1", + "effect_id": "effect@234546:234609", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_num((ctx.devalue(pat.n1) - ctx.devalue(pat.n2)))", + "semantic_text": null, + "referenced_pat_vars": [ + "n1", + "n2" + ], + "referenced_action_vars": [], + "range": { + "start": 234546, + "end": 234609 + } + }, + { + "id": "effect_2", + "effect_id": "effect@234628:234673", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_const(pat.output_type, t2, t3)", + "semantic_text": null, + "referenced_pat_vars": [ + "output_type" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 234628, + "end": 234673 + } + }, + { + "id": "effect_3", + "effect_id": "effect@234683:234705", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 234683, + "end": 234705 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0144", + "premises": [ + { + "target_id": "n1", + "label": "n1: ", + "plain_source": "n_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ n_1 $]" + }, + { + "target_id": "n2", + "label": "n2: ", + "plain_source": "n_2", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ n_2 $]" + }, + { + "target_id": "_t1", + "label": "_t1: Ecxbsub", + "plain_source": "upright(\"bsub\")(upright(\"output_type\"), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))))), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\"))))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $])) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxNode", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxPureOp", + "plain_source": "upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $]" + }, + { + "target_id": "_t4", + "label": "_t4: EcxConst", + "plain_source": "upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $]" + }, + { + "target_id": "_t5", + "label": "_t5: Ecxkw_const", + "plain_source": "upright(\"kw_const\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $]" + }, + { + "target_id": "_t6", + "label": "_t6: EcxNum", + "plain_source": "upright(\"_t6\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]" + }, + { + "target_id": "_t7", + "label": "_t7: EcxNode", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\"))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $]" + }, + { + "target_id": "_t8", + "label": "_t8: EcxPureOp", + "plain_source": "upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $]" + }, + { + "target_id": "_t9", + "label": "_t9: EcxConst", + "plain_source": "upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $]" + }, + { + "target_id": "_t10", + "label": "_t10: Ecxkw_const", + "plain_source": "upright(\"kw_const\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $]" + }, + { + "target_id": "_t11", + "label": "_t11: EcxNum", + "plain_source": "upright(\"_t11\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]" + } + ], + "side_conditions": [ + "n_1 == upright(\"_t6.a0\")", + "n_2 == upright(\"_t11.a0\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"EcxkwConst\")()", + "colored_source": "upright(\"EcxkwConst\")()" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"Num\")(n_1 - n_2)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Num\")(#text(fill: rgb(\"#B86A5B\"))[$ n_1 - n_2 $]) $]" + }, + { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"Const\")(upright(\"output_type\"), upright(\"EcxkwConst\")(), (upright(\"Num\")(n_1 - n_2)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], upright(\"EcxkwConst\")(), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Num\")(#text(fill: rgb(\"#B86A5B\"))[$ n_1 - n_2 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_3", + "from": { + "target_id": "_t1", + "label": "_t1: Ecxbsub", + "plain_source": "upright(\"bsub\")(upright(\"output_type\"), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))))), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\"))))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $])) $]" + }, + "to": { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"Const\")(upright(\"output_type\"), upright(\"EcxkwConst\")(), (upright(\"Num\")(n_1 - n_2)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], upright(\"EcxkwConst\")(), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Num\")(#text(fill: rgb(\"#B86A5B\"))[$ n_1 - n_2 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(n_1 \\ n_2 \\ upright(\"bsub\")(upright(\"output_type\"), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))))), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\")))))))) \\ upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\")))))) \\ upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\")))) \\ upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\")) \\ upright(\"kw_const\") \\ upright(\"_t6\") \\ upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\")))))) \\ upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\")))) \\ upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\")) \\ upright(\"kw_const\") \\ upright(\"_t11\"), upright(\"bsub\")(upright(\"output_type\"), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))))), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\")))))))) arrow.r.double upright(\"Const\")(upright(\"output_type\"), upright(\"EcxkwConst\")(), (upright(\"Num\")(n_1 - n_2)))) quad upright(\"if\") quad n_1 == upright(\"_t6.a0\") \\ n_2 == upright(\"_t11.a0\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ n_1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ n_2 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $])) $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], upright(\"EcxkwConst\")(), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Num\")(#text(fill: rgb(\"#B86A5B\"))[$ n_1 - n_2 $]) $])) $]) quad upright(\"if\") quad n_1 == upright(\"_t6.a0\") \\ n_2 == upright(\"_t11.a0\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7470_5_MyTxEggccExtraction_add_rule__r0145__aa1d741c614b269d", + "display_name": "r0145", + "rule_name": "r0145", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 234719, + "line": 7470, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 234719, + "end": 235023 + }, + "pattern_range": { + "start": 234770, + "end": 234781 + }, + "action_range": { + "start": 234783, + "end": 235022 + } + }, + "nodes": [ + { + "id": "n1", + "kind": "query", + "dsl_type": "", + "label": "n1: ", + "range": { + "start": 123240, + "end": 123287 + }, + "inputs": [] + }, + { + "id": "n2", + "kind": "query", + "dsl_type": "", + "label": "n2: ", + "range": { + "start": 123292, + "end": 123339 + }, + "inputs": [] + }, + { + "id": "output_type", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "output_type: EcxType", + "range": { + "start": 123344, + "end": 123384 + }, + "inputs": [] + }, + { + "id": "ty2", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty2: EcxType", + "range": { + "start": 123389, + "end": 123421 + }, + "inputs": [] + }, + { + "id": "ty3", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty3: EcxType", + "range": { + "start": 123426, + "end": 123458 + }, + "inputs": [] + }, + { + "id": "_t5", + "kind": "query", + "dsl_type": "Ecxkw_const", + "label": "_t5: Ecxkw_const", + "range": { + "start": 123463, + "end": 123494 + }, + "inputs": [] + }, + { + "id": "_t6", + "kind": "query", + "dsl_type": "EcxNum", + "label": "_t6: EcxNum", + "range": { + "start": 123499, + "end": 123525 + }, + "inputs": [] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxConst", + "label": "_t4: EcxConst", + "range": { + "start": 123530, + "end": 123574 + }, + "inputs": [ + "ty2", + "_t5", + "_t6" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t3: EcxPureOp", + "range": { + "start": 123579, + "end": 123612 + }, + "inputs": [ + "_t4" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t2: EcxNode", + "range": { + "start": 123617, + "end": 123648 + }, + "inputs": [ + "_t3" + ] + }, + { + "id": "_t10", + "kind": "query", + "dsl_type": "Ecxkw_const", + "label": "_t10: Ecxkw_const", + "range": { + "start": 123653, + "end": 123685 + }, + "inputs": [] + }, + { + "id": "_t11", + "kind": "query", + "dsl_type": "EcxNum", + "label": "_t11: EcxNum", + "range": { + "start": 123690, + "end": 123717 + }, + "inputs": [] + }, + { + "id": "_t9", + "kind": "query", + "dsl_type": "EcxConst", + "label": "_t9: EcxConst", + "range": { + "start": 123722, + "end": 123768 + }, + "inputs": [ + "ty3", + "_t10", + "_t11" + ] + }, + { + "id": "_t8", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t8: EcxPureOp", + "range": { + "start": 123773, + "end": 123806 + }, + "inputs": [ + "_t9" + ] + }, + { + "id": "_t7", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t7: EcxNode", + "range": { + "start": 123811, + "end": 123842 + }, + "inputs": [ + "_t8" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "Ecxbmul", + "label": "_t1: Ecxbmul", + "range": { + "start": 123847, + "end": 123898 + }, + "inputs": [ + "output_type", + "_t2", + "_t7" + ] + } + ], + "edges": [ + { + "from": "_t4", + "to": "ty2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "_t5", + "kind": "operand", + "index": 1 + }, + { + "from": "_t4", + "to": "_t6", + "kind": "operand", + "index": 2 + }, + { + "from": "_t3", + "to": "_t4", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "_t3", + "kind": "operand", + "index": 0 + }, + { + "from": "_t9", + "to": "ty3", + "kind": "operand", + "index": 0 + }, + { + "from": "_t9", + "to": "_t10", + "kind": "operand", + "index": 1 + }, + { + "from": "_t9", + "to": "_t11", + "kind": "operand", + "index": 2 + }, + { + "from": "_t8", + "to": "_t9", + "kind": "operand", + "index": 0 + }, + { + "from": "_t7", + "to": "_t8", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "output_type", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "_t7", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "n1", + "n2", + "output_type", + "ty2", + "ty3", + "_t1", + "_t2", + "_t3", + "_t4", + "_t5", + "_t6", + "_t7", + "_t8", + "_t9", + "_t10", + "_t11" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "n1.handle().eq(&_t6.handle_a0())", + "semantic_text": "n1 == _t6.a0", + "referenced_vars": [ + "_t6", + "n1" + ], + "range": { + "start": 124246, + "end": 124248 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "n2.handle().eq(&_t11.handle_a0())", + "semantic_text": "n2 == _t11.a0", + "referenced_vars": [ + "_t11", + "n2" + ], + "range": { + "start": 124262, + "end": 124264 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@234813:234837", + "bound_var": "t2", + "source_text": "ctx.insert_ecxkw_const()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 234813, + "end": 234837 + } + }, + { + "id": "effect_1", + "effect_id": "effect@234856:234919", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_num((ctx.devalue(pat.n1) * ctx.devalue(pat.n2)))", + "semantic_text": null, + "referenced_pat_vars": [ + "n1", + "n2" + ], + "referenced_action_vars": [], + "range": { + "start": 234856, + "end": 234919 + } + }, + { + "id": "effect_2", + "effect_id": "effect@234938:234983", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_const(pat.output_type, t2, t3)", + "semantic_text": null, + "referenced_pat_vars": [ + "output_type" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 234938, + "end": 234983 + } + }, + { + "id": "effect_3", + "effect_id": "effect@234993:235015", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 234993, + "end": 235015 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0145", + "premises": [ + { + "target_id": "n1", + "label": "n1: ", + "plain_source": "n_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ n_1 $]" + }, + { + "target_id": "n2", + "label": "n2: ", + "plain_source": "n_2", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ n_2 $]" + }, + { + "target_id": "_t1", + "label": "_t1: Ecxbmul", + "plain_source": "upright(\"bmul\")(upright(\"output_type\"), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))))), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\"))))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $])) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxNode", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxPureOp", + "plain_source": "upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $]" + }, + { + "target_id": "_t4", + "label": "_t4: EcxConst", + "plain_source": "upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $]" + }, + { + "target_id": "_t5", + "label": "_t5: Ecxkw_const", + "plain_source": "upright(\"kw_const\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $]" + }, + { + "target_id": "_t6", + "label": "_t6: EcxNum", + "plain_source": "upright(\"_t6\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]" + }, + { + "target_id": "_t7", + "label": "_t7: EcxNode", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\"))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $]" + }, + { + "target_id": "_t8", + "label": "_t8: EcxPureOp", + "plain_source": "upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $]" + }, + { + "target_id": "_t9", + "label": "_t9: EcxConst", + "plain_source": "upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $]" + }, + { + "target_id": "_t10", + "label": "_t10: Ecxkw_const", + "plain_source": "upright(\"kw_const\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $]" + }, + { + "target_id": "_t11", + "label": "_t11: EcxNum", + "plain_source": "upright(\"_t11\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]" + } + ], + "side_conditions": [ + "n_1 == upright(\"_t6.a0\")", + "n_2 == upright(\"_t11.a0\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"EcxkwConst\")()", + "colored_source": "upright(\"EcxkwConst\")()" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"Num\")(n_1 * n_2)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Num\")(#text(fill: rgb(\"#B86A5B\"))[$ n_1 * n_2 $]) $]" + }, + { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"Const\")(upright(\"output_type\"), upright(\"EcxkwConst\")(), (upright(\"Num\")(n_1 * n_2)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], upright(\"EcxkwConst\")(), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Num\")(#text(fill: rgb(\"#B86A5B\"))[$ n_1 * n_2 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_3", + "from": { + "target_id": "_t1", + "label": "_t1: Ecxbmul", + "plain_source": "upright(\"bmul\")(upright(\"output_type\"), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))))), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\"))))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $])) $]" + }, + "to": { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"Const\")(upright(\"output_type\"), upright(\"EcxkwConst\")(), (upright(\"Num\")(n_1 * n_2)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], upright(\"EcxkwConst\")(), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Num\")(#text(fill: rgb(\"#B86A5B\"))[$ n_1 * n_2 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(n_1 \\ n_2 \\ upright(\"bmul\")(upright(\"output_type\"), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))))), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\")))))))) \\ upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\")))))) \\ upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\")))) \\ upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\")) \\ upright(\"kw_const\") \\ upright(\"_t6\") \\ upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\")))))) \\ upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\")))) \\ upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\")) \\ upright(\"kw_const\") \\ upright(\"_t11\"), upright(\"bmul\")(upright(\"output_type\"), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))))), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\")))))))) arrow.r.double upright(\"Const\")(upright(\"output_type\"), upright(\"EcxkwConst\")(), (upright(\"Num\")(n_1 * n_2)))) quad upright(\"if\") quad n_1 == upright(\"_t6.a0\") \\ n_2 == upright(\"_t11.a0\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ n_1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ n_2 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $])) $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], upright(\"EcxkwConst\")(), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Num\")(#text(fill: rgb(\"#B86A5B\"))[$ n_1 * n_2 $]) $])) $]) quad upright(\"if\") quad n_1 == upright(\"_t6.a0\") \\ n_2 == upright(\"_t11.a0\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7476_5_MyTxEggccExtraction_add_rule__r0146__4ffdefef23a10092", + "display_name": "r0146", + "rule_name": "r0146", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 235029, + "line": 7476, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 235029, + "end": 235333 + }, + "pattern_range": { + "start": 235080, + "end": 235091 + }, + "action_range": { + "start": 235093, + "end": 235332 + } + }, + "nodes": [ + { + "id": "n1", + "kind": "query", + "dsl_type": "", + "label": "n1: ", + "range": { + "start": 124679, + "end": 124726 + }, + "inputs": [] + }, + { + "id": "n2", + "kind": "query", + "dsl_type": "", + "label": "n2: ", + "range": { + "start": 124731, + "end": 124778 + }, + "inputs": [] + }, + { + "id": "output_type", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "output_type: EcxType", + "range": { + "start": 124783, + "end": 124823 + }, + "inputs": [] + }, + { + "id": "ty2", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty2: EcxType", + "range": { + "start": 124828, + "end": 124860 + }, + "inputs": [] + }, + { + "id": "ty3", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty3: EcxType", + "range": { + "start": 124865, + "end": 124897 + }, + "inputs": [] + }, + { + "id": "_t5", + "kind": "query", + "dsl_type": "Ecxkw_const", + "label": "_t5: Ecxkw_const", + "range": { + "start": 124902, + "end": 124933 + }, + "inputs": [] + }, + { + "id": "_t6", + "kind": "query", + "dsl_type": "EcxNum", + "label": "_t6: EcxNum", + "range": { + "start": 124938, + "end": 124964 + }, + "inputs": [] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxConst", + "label": "_t4: EcxConst", + "range": { + "start": 124969, + "end": 125013 + }, + "inputs": [ + "ty2", + "_t5", + "_t6" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t3: EcxPureOp", + "range": { + "start": 125018, + "end": 125051 + }, + "inputs": [ + "_t4" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t2: EcxNode", + "range": { + "start": 125056, + "end": 125087 + }, + "inputs": [ + "_t3" + ] + }, + { + "id": "_t10", + "kind": "query", + "dsl_type": "Ecxkw_const", + "label": "_t10: Ecxkw_const", + "range": { + "start": 125092, + "end": 125124 + }, + "inputs": [] + }, + { + "id": "_t11", + "kind": "query", + "dsl_type": "EcxNum", + "label": "_t11: EcxNum", + "range": { + "start": 125129, + "end": 125156 + }, + "inputs": [] + }, + { + "id": "_t9", + "kind": "query", + "dsl_type": "EcxConst", + "label": "_t9: EcxConst", + "range": { + "start": 125161, + "end": 125207 + }, + "inputs": [ + "ty3", + "_t10", + "_t11" + ] + }, + { + "id": "_t8", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t8: EcxPureOp", + "range": { + "start": 125212, + "end": 125245 + }, + "inputs": [ + "_t9" + ] + }, + { + "id": "_t7", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t7: EcxNode", + "range": { + "start": 125250, + "end": 125281 + }, + "inputs": [ + "_t8" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "Ecxbdiv", + "label": "_t1: Ecxbdiv", + "range": { + "start": 125286, + "end": 125337 + }, + "inputs": [ + "output_type", + "_t2", + "_t7" + ] + } + ], + "edges": [ + { + "from": "_t4", + "to": "ty2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "_t5", + "kind": "operand", + "index": 1 + }, + { + "from": "_t4", + "to": "_t6", + "kind": "operand", + "index": 2 + }, + { + "from": "_t3", + "to": "_t4", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "_t3", + "kind": "operand", + "index": 0 + }, + { + "from": "_t9", + "to": "ty3", + "kind": "operand", + "index": 0 + }, + { + "from": "_t9", + "to": "_t10", + "kind": "operand", + "index": 1 + }, + { + "from": "_t9", + "to": "_t11", + "kind": "operand", + "index": 2 + }, + { + "from": "_t8", + "to": "_t9", + "kind": "operand", + "index": 0 + }, + { + "from": "_t7", + "to": "_t8", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "output_type", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "_t7", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "n1", + "n2", + "output_type", + "ty2", + "ty3", + "_t1", + "_t2", + "_t3", + "_t4", + "_t5", + "_t6", + "_t7", + "_t8", + "_t9", + "_t10", + "_t11" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "n1.handle().eq(&_t6.handle_a0())", + "semantic_text": "n1 == _t6.a0", + "referenced_vars": [ + "_t6", + "n1" + ], + "range": { + "start": 125685, + "end": 125687 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "n2.handle().eq(&_t11.handle_a0())", + "semantic_text": "n2 == _t11.a0", + "referenced_vars": [ + "_t11", + "n2" + ], + "range": { + "start": 125701, + "end": 125703 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@235123:235147", + "bound_var": "t2", + "source_text": "ctx.insert_ecxkw_const()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 235123, + "end": 235147 + } + }, + { + "id": "effect_1", + "effect_id": "effect@235166:235229", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_num((ctx.devalue(pat.n1) / ctx.devalue(pat.n2)))", + "semantic_text": null, + "referenced_pat_vars": [ + "n1", + "n2" + ], + "referenced_action_vars": [], + "range": { + "start": 235166, + "end": 235229 + } + }, + { + "id": "effect_2", + "effect_id": "effect@235248:235293", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_const(pat.output_type, t2, t3)", + "semantic_text": null, + "referenced_pat_vars": [ + "output_type" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 235248, + "end": 235293 + } + }, + { + "id": "effect_3", + "effect_id": "effect@235303:235325", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 235303, + "end": 235325 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0146", + "premises": [ + { + "target_id": "n1", + "label": "n1: ", + "plain_source": "n_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ n_1 $]" + }, + { + "target_id": "n2", + "label": "n2: ", + "plain_source": "n_2", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ n_2 $]" + }, + { + "target_id": "_t1", + "label": "_t1: Ecxbdiv", + "plain_source": "upright(\"bdiv\")(upright(\"output_type\"), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))))), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\"))))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $])) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxNode", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxPureOp", + "plain_source": "upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $]" + }, + { + "target_id": "_t4", + "label": "_t4: EcxConst", + "plain_source": "upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $]" + }, + { + "target_id": "_t5", + "label": "_t5: Ecxkw_const", + "plain_source": "upright(\"kw_const\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $]" + }, + { + "target_id": "_t6", + "label": "_t6: EcxNum", + "plain_source": "upright(\"_t6\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]" + }, + { + "target_id": "_t7", + "label": "_t7: EcxNode", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\"))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $]" + }, + { + "target_id": "_t8", + "label": "_t8: EcxPureOp", + "plain_source": "upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $]" + }, + { + "target_id": "_t9", + "label": "_t9: EcxConst", + "plain_source": "upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $]" + }, + { + "target_id": "_t10", + "label": "_t10: Ecxkw_const", + "plain_source": "upright(\"kw_const\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $]" + }, + { + "target_id": "_t11", + "label": "_t11: EcxNum", + "plain_source": "upright(\"_t11\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]" + } + ], + "side_conditions": [ + "n_1 == upright(\"_t6.a0\")", + "n_2 == upright(\"_t11.a0\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"EcxkwConst\")()", + "colored_source": "upright(\"EcxkwConst\")()" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"Num\")(n_1 / n_2)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Num\")(#text(fill: rgb(\"#B86A5B\"))[$ n_1 / n_2 $]) $]" + }, + { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"Const\")(upright(\"output_type\"), upright(\"EcxkwConst\")(), (upright(\"Num\")(n_1 / n_2)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], upright(\"EcxkwConst\")(), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Num\")(#text(fill: rgb(\"#B86A5B\"))[$ n_1 / n_2 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_3", + "from": { + "target_id": "_t1", + "label": "_t1: Ecxbdiv", + "plain_source": "upright(\"bdiv\")(upright(\"output_type\"), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))))), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\"))))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $])) $]" + }, + "to": { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"Const\")(upright(\"output_type\"), upright(\"EcxkwConst\")(), (upright(\"Num\")(n_1 / n_2)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], upright(\"EcxkwConst\")(), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Num\")(#text(fill: rgb(\"#B86A5B\"))[$ n_1 / n_2 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(n_1 \\ n_2 \\ upright(\"bdiv\")(upright(\"output_type\"), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))))), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\")))))))) \\ upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\")))))) \\ upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\")))) \\ upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\")) \\ upright(\"kw_const\") \\ upright(\"_t6\") \\ upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\")))))) \\ upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\")))) \\ upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\")) \\ upright(\"kw_const\") \\ upright(\"_t11\"), upright(\"bdiv\")(upright(\"output_type\"), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))))), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\")))))))) arrow.r.double upright(\"Const\")(upright(\"output_type\"), upright(\"EcxkwConst\")(), (upright(\"Num\")(n_1 / n_2)))) quad upright(\"if\") quad n_1 == upright(\"_t6.a0\") \\ n_2 == upright(\"_t11.a0\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ n_1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ n_2 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $])) $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], upright(\"EcxkwConst\")(), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Num\")(#text(fill: rgb(\"#B86A5B\"))[$ n_1 / n_2 $]) $])) $]) quad upright(\"if\") quad n_1 == upright(\"_t6.a0\") \\ n_2 == upright(\"_t11.a0\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7482_5_MyTxEggccExtraction_add_rule__r0147__f3362a0ca36f6b8e", + "display_name": "r0147", + "rule_name": "r0147", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 235339, + "line": 7482, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 235339, + "end": 235644 + }, + "pattern_range": { + "start": 235390, + "end": 235401 + }, + "action_range": { + "start": 235403, + "end": 235643 + } + }, + "nodes": [ + { + "id": "n1", + "kind": "query", + "dsl_type": "", + "label": "n1: ", + "range": { + "start": 126117, + "end": 126164 + }, + "inputs": [] + }, + { + "id": "n2", + "kind": "query", + "dsl_type": "", + "label": "n2: ", + "range": { + "start": 126169, + "end": 126216 + }, + "inputs": [] + }, + { + "id": "output_type", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "output_type: EcxType", + "range": { + "start": 126221, + "end": 126261 + }, + "inputs": [] + }, + { + "id": "ty2", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty2: EcxType", + "range": { + "start": 126266, + "end": 126298 + }, + "inputs": [] + }, + { + "id": "ty3", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty3: EcxType", + "range": { + "start": 126303, + "end": 126335 + }, + "inputs": [] + }, + { + "id": "_t5", + "kind": "query", + "dsl_type": "Ecxkw_const", + "label": "_t5: Ecxkw_const", + "range": { + "start": 126340, + "end": 126371 + }, + "inputs": [] + }, + { + "id": "_t6", + "kind": "query", + "dsl_type": "EcxNum", + "label": "_t6: EcxNum", + "range": { + "start": 126376, + "end": 126402 + }, + "inputs": [] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxConst", + "label": "_t4: EcxConst", + "range": { + "start": 126407, + "end": 126451 + }, + "inputs": [ + "ty2", + "_t5", + "_t6" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t3: EcxPureOp", + "range": { + "start": 126456, + "end": 126489 + }, + "inputs": [ + "_t4" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t2: EcxNode", + "range": { + "start": 126494, + "end": 126525 + }, + "inputs": [ + "_t3" + ] + }, + { + "id": "_t10", + "kind": "query", + "dsl_type": "Ecxkw_const", + "label": "_t10: Ecxkw_const", + "range": { + "start": 126530, + "end": 126562 + }, + "inputs": [] + }, + { + "id": "_t11", + "kind": "query", + "dsl_type": "EcxNum", + "label": "_t11: EcxNum", + "range": { + "start": 126567, + "end": 126594 + }, + "inputs": [] + }, + { + "id": "_t9", + "kind": "query", + "dsl_type": "EcxConst", + "label": "_t9: EcxConst", + "range": { + "start": 126599, + "end": 126645 + }, + "inputs": [ + "ty3", + "_t10", + "_t11" + ] + }, + { + "id": "_t8", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t8: EcxPureOp", + "range": { + "start": 126650, + "end": 126683 + }, + "inputs": [ + "_t9" + ] + }, + { + "id": "_t7", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t7: EcxNode", + "range": { + "start": 126688, + "end": 126719 + }, + "inputs": [ + "_t8" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "Ecxblt", + "label": "_t1: Ecxblt", + "range": { + "start": 126724, + "end": 126774 + }, + "inputs": [ + "output_type", + "_t2", + "_t7" + ] + } + ], + "edges": [ + { + "from": "_t4", + "to": "ty2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "_t5", + "kind": "operand", + "index": 1 + }, + { + "from": "_t4", + "to": "_t6", + "kind": "operand", + "index": 2 + }, + { + "from": "_t3", + "to": "_t4", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "_t3", + "kind": "operand", + "index": 0 + }, + { + "from": "_t9", + "to": "ty3", + "kind": "operand", + "index": 0 + }, + { + "from": "_t9", + "to": "_t10", + "kind": "operand", + "index": 1 + }, + { + "from": "_t9", + "to": "_t11", + "kind": "operand", + "index": 2 + }, + { + "from": "_t8", + "to": "_t9", + "kind": "operand", + "index": 0 + }, + { + "from": "_t7", + "to": "_t8", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "output_type", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "_t7", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "n1", + "n2", + "output_type", + "ty2", + "ty3", + "_t1", + "_t2", + "_t3", + "_t4", + "_t5", + "_t6", + "_t7", + "_t8", + "_t9", + "_t10", + "_t11" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "n1.handle().eq(&_t6.handle_a0())", + "semantic_text": "n1 == _t6.a0", + "referenced_vars": [ + "_t6", + "n1" + ], + "range": { + "start": 127122, + "end": 127124 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "n2.handle().eq(&_t11.handle_a0())", + "semantic_text": "n2 == _t11.a0", + "referenced_vars": [ + "_t11", + "n2" + ], + "range": { + "start": 127138, + "end": 127140 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@235433:235457", + "bound_var": "t2", + "source_text": "ctx.insert_ecxkw_const()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 235433, + "end": 235457 + } + }, + { + "id": "effect_1", + "effect_id": "effect@235476:235540", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_bool((ctx.devalue(pat.n1) < ctx.devalue(pat.n2)))", + "semantic_text": null, + "referenced_pat_vars": [ + "n1", + "n2" + ], + "referenced_action_vars": [], + "range": { + "start": 235476, + "end": 235540 + } + }, + { + "id": "effect_2", + "effect_id": "effect@235559:235604", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_const(pat.output_type, t2, t3)", + "semantic_text": null, + "referenced_pat_vars": [ + "output_type" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 235559, + "end": 235604 + } + }, + { + "id": "effect_3", + "effect_id": "effect@235614:235636", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 235614, + "end": 235636 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0147", + "premises": [ + { + "target_id": "n1", + "label": "n1: ", + "plain_source": "n_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ n_1 $]" + }, + { + "target_id": "n2", + "label": "n2: ", + "plain_source": "n_2", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ n_2 $]" + }, + { + "target_id": "_t1", + "label": "_t1: Ecxblt", + "plain_source": "upright(\"blt\")(upright(\"output_type\"), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))))), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\"))))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $])) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxNode", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxPureOp", + "plain_source": "upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $]" + }, + { + "target_id": "_t4", + "label": "_t4: EcxConst", + "plain_source": "upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $]" + }, + { + "target_id": "_t5", + "label": "_t5: Ecxkw_const", + "plain_source": "upright(\"kw_const\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $]" + }, + { + "target_id": "_t6", + "label": "_t6: EcxNum", + "plain_source": "upright(\"_t6\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]" + }, + { + "target_id": "_t7", + "label": "_t7: EcxNode", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\"))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $]" + }, + { + "target_id": "_t8", + "label": "_t8: EcxPureOp", + "plain_source": "upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $]" + }, + { + "target_id": "_t9", + "label": "_t9: EcxConst", + "plain_source": "upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $]" + }, + { + "target_id": "_t10", + "label": "_t10: Ecxkw_const", + "plain_source": "upright(\"kw_const\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $]" + }, + { + "target_id": "_t11", + "label": "_t11: EcxNum", + "plain_source": "upright(\"_t11\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]" + } + ], + "side_conditions": [ + "n_1 == upright(\"_t6.a0\")", + "n_2 == upright(\"_t11.a0\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"EcxkwConst\")()", + "colored_source": "upright(\"EcxkwConst\")()" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"Bool\")(n_1 < n_2)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Bool\")(#text(fill: rgb(\"#B86A5B\"))[$ n_1 < n_2 $]) $]" + }, + { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"Const\")(upright(\"output_type\"), upright(\"EcxkwConst\")(), (upright(\"Bool\")(n_1 < n_2)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], upright(\"EcxkwConst\")(), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Bool\")(#text(fill: rgb(\"#B86A5B\"))[$ n_1 < n_2 $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_3", + "from": { + "target_id": "_t1", + "label": "_t1: Ecxblt", + "plain_source": "upright(\"blt\")(upright(\"output_type\"), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))))), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\"))))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $])) $]" + }, + "to": { + "target_id": "effect:effect_2", + "label": "t1", + "plain_source": "upright(\"Const\")(upright(\"output_type\"), upright(\"EcxkwConst\")(), (upright(\"Bool\")(n_1 < n_2)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], upright(\"EcxkwConst\")(), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Bool\")(#text(fill: rgb(\"#B86A5B\"))[$ n_1 < n_2 $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(n_1 \\ n_2 \\ upright(\"blt\")(upright(\"output_type\"), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))))), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\")))))))) \\ upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\")))))) \\ upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\")))) \\ upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\")) \\ upright(\"kw_const\") \\ upright(\"_t6\") \\ upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\")))))) \\ upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\")))) \\ upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\")) \\ upright(\"kw_const\") \\ upright(\"_t11\"), upright(\"blt\")(upright(\"output_type\"), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty2, upright(\"_t5\"), upright(\"_t6\"))))))), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(ty3, upright(\"_t10\"), upright(\"_t11\")))))))) arrow.r.double upright(\"Const\")(upright(\"output_type\"), upright(\"EcxkwConst\")(), (upright(\"Bool\")(n_1 < n_2)))) quad upright(\"if\") quad n_1 == upright(\"_t6.a0\") \\ n_2 == upright(\"_t11.a0\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ n_1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ n_2 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty2 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ ty3 $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) $])) $])) $])) $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"output_type\") $], upright(\"EcxkwConst\")(), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Bool\")(#text(fill: rgb(\"#B86A5B\"))[$ n_1 < n_2 $]) $])) $]) quad upright(\"if\") quad n_1 == upright(\"_t6.a0\") \\ n_2 == upright(\"_t11.a0\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7488_5_MyTxEggccExtraction_add_rule__r0148__91894d6f5faaab99", + "display_name": "r0148", + "rule_name": "r0148", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 235650, + "line": 7488, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 235650, + "end": 235838 + }, + "pattern_range": { + "start": 235695, + "end": 235706 + }, + "action_range": { + "start": 235708, + "end": 235837 + } + }, + "nodes": [ + { + "id": "cost1", + "kind": "query", + "dsl_type": "", + "label": "cost1: ", + "range": { + "start": 127417, + "end": 127470 + }, + "inputs": [] + }, + { + "id": "cost2", + "kind": "query", + "dsl_type": "", + "label": "cost2: ", + "range": { + "start": 127475, + "end": 127528 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxTermAndCost", + "label": "lhs: EcxTermAndCost", + "range": { + "start": 127533, + "end": 127572 + }, + "inputs": [] + }, + { + "id": "t1", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "t1: EcxExpr", + "range": { + "start": 127577, + "end": 127608 + }, + "inputs": [] + }, + { + "id": "t2", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "t2: EcxExpr", + "range": { + "start": 127613, + "end": 127644 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxExprAndCost", + "label": "_t2: EcxExprAndCost", + "range": { + "start": 127649, + "end": 127686 + }, + "inputs": [ + "t1" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxExprAndCost", + "label": "_t3: EcxExprAndCost", + "range": { + "start": 127691, + "end": 127728 + }, + "inputs": [ + "t2" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSmaller", + "label": "_t1: EcxSmaller", + "range": { + "start": 127733, + "end": 127773 + }, + "inputs": [ + "_t2", + "_t3" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "t1", + "kind": "operand", + "index": 0 + }, + { + "from": "_t3", + "to": "t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t3", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cost1", + "cost2", + "lhs", + "t1", + "t2", + "_t1", + "_t2", + "_t3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "cost1.handle().eq(&_t2.handle_a1())", + "semantic_text": "cost1 == _t2.a1", + "referenced_vars": [ + "_t2", + "cost1" + ], + "range": { + "start": 128043, + "end": 128045 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "cost2.handle().eq(&_t3.handle_a1())", + "semantic_text": "cost2 == _t3.a1", + "referenced_vars": [ + "_t3", + "cost2" + ], + "range": { + "start": 128063, + "end": 128065 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 128083, + "end": 128085 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "cost1.handle().le(&cost2.handle())", + "semantic_text": "cost1 <= cost2", + "referenced_vars": [ + "cost1", + "cost2" + ], + "range": { + "start": 128103, + "end": 128105 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@235738:235798", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_expr_and_cost(pat.t1, ctx.devalue(pat.cost1))", + "semantic_text": null, + "referenced_pat_vars": [ + "cost1", + "t1" + ], + "referenced_action_vars": [], + "range": { + "start": 235738, + "end": 235798 + } + }, + { + "id": "effect_1", + "effect_id": "effect@235808:235830", + "bound_var": null, + "source_text": "ctx.union(pat.lhs, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 235808, + "end": 235830 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0148", + "premises": [ + { + "target_id": "cost1", + "label": "cost1: ", + "plain_source": "cost1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $]" + }, + { + "target_id": "cost2", + "label": "cost2: ", + "plain_source": "cost2", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSmaller", + "plain_source": "upright(\"Smaller\")(upright(\"_t2\"), upright(\"_t3\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Smaller\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxExprAndCost", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxExprAndCost", + "plain_source": "upright(\"_t3\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]" + } + ], + "side_conditions": [ + "upright(\"cost1\") == upright(\"_t2.a1\")", + "upright(\"cost2\") == upright(\"_t3.a1\")", + "upright(\"lhs\") == upright(\"_t1\")", + "upright(\"cost1\") <= upright(\"cost2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "t_1", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ t_1 $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "lhs", + "label": "lhs: EcxTermAndCost", + "plain_source": "upright(\"lhs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "t_1", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ t_1 $]" + } + } + ], + "formula_source": { + "plain": "frac(cost1 \\ cost2 \\ upright(\"Smaller\")(upright(\"_t2\"), upright(\"_t3\")) \\ upright(\"_t2\") \\ upright(\"_t3\"), upright(\"lhs\") arrow.r.double t_1) quad upright(\"if\") quad upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"cost2\") == upright(\"_t3.a1\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") <= upright(\"cost2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Smaller\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ t_1 $]) quad upright(\"if\") quad upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"cost2\") == upright(\"_t3.a1\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") <= upright(\"cost2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7492_5_MyTxEggccExtraction_add_rule__r0149__09df5d5bf2c6e511", + "display_name": "r0149", + "rule_name": "r0149", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 235844, + "line": 7492, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 235844, + "end": 236032 + }, + "pattern_range": { + "start": 235889, + "end": 235900 + }, + "action_range": { + "start": 235902, + "end": 236031 + } + }, + "nodes": [ + { + "id": "cost1", + "kind": "query", + "dsl_type": "", + "label": "cost1: ", + "range": { + "start": 128382, + "end": 128435 + }, + "inputs": [] + }, + { + "id": "cost2", + "kind": "query", + "dsl_type": "", + "label": "cost2: ", + "range": { + "start": 128440, + "end": 128493 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxTermAndCost", + "label": "lhs: EcxTermAndCost", + "range": { + "start": 128498, + "end": 128537 + }, + "inputs": [] + }, + { + "id": "t1", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "t1: EcxExpr", + "range": { + "start": 128542, + "end": 128573 + }, + "inputs": [] + }, + { + "id": "t2", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "t2: EcxExpr", + "range": { + "start": 128578, + "end": 128609 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxExprAndCost", + "label": "_t2: EcxExprAndCost", + "range": { + "start": 128614, + "end": 128651 + }, + "inputs": [ + "t1" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxExprAndCost", + "label": "_t3: EcxExprAndCost", + "range": { + "start": 128656, + "end": 128693 + }, + "inputs": [ + "t2" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSmaller", + "label": "_t1: EcxSmaller", + "range": { + "start": 128698, + "end": 128738 + }, + "inputs": [ + "_t2", + "_t3" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "t1", + "kind": "operand", + "index": 0 + }, + { + "from": "_t3", + "to": "t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t3", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cost1", + "cost2", + "lhs", + "t1", + "t2", + "_t1", + "_t2", + "_t3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "cost1.handle().eq(&_t2.handle_a1())", + "semantic_text": "cost1 == _t2.a1", + "referenced_vars": [ + "_t2", + "cost1" + ], + "range": { + "start": 129008, + "end": 129010 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "cost2.handle().eq(&_t3.handle_a1())", + "semantic_text": "cost2 == _t3.a1", + "referenced_vars": [ + "_t3", + "cost2" + ], + "range": { + "start": 129028, + "end": 129030 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 129048, + "end": 129050 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "cost1.handle().gt(&cost2.handle())", + "semantic_text": "cost1 > cost2", + "referenced_vars": [ + "cost1", + "cost2" + ], + "range": { + "start": 129068, + "end": 129070 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@235932:235992", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_expr_and_cost(pat.t2, ctx.devalue(pat.cost2))", + "semantic_text": null, + "referenced_pat_vars": [ + "cost2", + "t2" + ], + "referenced_action_vars": [], + "range": { + "start": 235932, + "end": 235992 + } + }, + { + "id": "effect_1", + "effect_id": "effect@236002:236024", + "bound_var": null, + "source_text": "ctx.union(pat.lhs, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 236002, + "end": 236024 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0149", + "premises": [ + { + "target_id": "cost1", + "label": "cost1: ", + "plain_source": "cost1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $]" + }, + { + "target_id": "cost2", + "label": "cost2: ", + "plain_source": "cost2", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSmaller", + "plain_source": "upright(\"Smaller\")(upright(\"_t2\"), upright(\"_t3\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Smaller\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxExprAndCost", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxExprAndCost", + "plain_source": "upright(\"_t3\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]" + } + ], + "side_conditions": [ + "upright(\"cost1\") == upright(\"_t2.a1\")", + "upright(\"cost2\") == upright(\"_t3.a1\")", + "upright(\"lhs\") == upright(\"_t1\")", + "upright(\"cost1\") > upright(\"cost2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"ExprAndCost\")(t_2, cost2)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ExprAndCost\")(#text(fill: rgb(\"#5F7A8A\"))[$ t_2 $], #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "lhs", + "label": "lhs: EcxTermAndCost", + "plain_source": "upright(\"lhs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"ExprAndCost\")(t_2, cost2)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ExprAndCost\")(#text(fill: rgb(\"#5F7A8A\"))[$ t_2 $], #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(cost1 \\ cost2 \\ upright(\"Smaller\")(upright(\"_t2\"), upright(\"_t3\")) \\ upright(\"_t2\") \\ upright(\"_t3\"), upright(\"lhs\") arrow.r.double upright(\"ExprAndCost\")(t_2, cost2)) quad upright(\"if\") quad upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"cost2\") == upright(\"_t3.a1\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") > upright(\"cost2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Smaller\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"ExprAndCost\")(#text(fill: rgb(\"#5F7A8A\"))[$ t_2 $], #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]) $]) quad upright(\"if\") quad upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"cost2\") == upright(\"_t3.a1\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") > upright(\"cost2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7496_5_MyTxEggccExtraction_add_rule__r0150__7df19cf02e278ad3", + "display_name": "r0150", + "rule_name": "r0150", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 236038, + "line": 7496, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 236038, + "end": 236229 + }, + "pattern_range": { + "start": 236083, + "end": 236094 + }, + "action_range": { + "start": 236096, + "end": 236228 + } + }, + "nodes": [ + { + "id": "cost1", + "kind": "query", + "dsl_type": "", + "label": "cost1: ", + "range": { + "start": 129359, + "end": 129412 + }, + "inputs": [] + }, + { + "id": "cost2", + "kind": "query", + "dsl_type": "", + "label": "cost2: ", + "range": { + "start": 129417, + "end": 129470 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxTermAndCost", + "label": "lhs: EcxTermAndCost", + "range": { + "start": 129475, + "end": 129514 + }, + "inputs": [] + }, + { + "id": "t1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "t1: EcxOperand", + "range": { + "start": 129519, + "end": 129553 + }, + "inputs": [] + }, + { + "id": "t2", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "t2: EcxOperand", + "range": { + "start": 129558, + "end": 129592 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxOperandAndCost", + "label": "_t2: EcxOperandAndCost", + "range": { + "start": 129597, + "end": 129637 + }, + "inputs": [ + "t1" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxOperandAndCost", + "label": "_t3: EcxOperandAndCost", + "range": { + "start": 129642, + "end": 129682 + }, + "inputs": [ + "t2" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSmaller", + "label": "_t1: EcxSmaller", + "range": { + "start": 129687, + "end": 129727 + }, + "inputs": [ + "_t2", + "_t3" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "t1", + "kind": "operand", + "index": 0 + }, + { + "from": "_t3", + "to": "t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t3", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cost1", + "cost2", + "lhs", + "t1", + "t2", + "_t1", + "_t2", + "_t3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "cost1.handle().eq(&_t2.handle_a1())", + "semantic_text": "cost1 == _t2.a1", + "referenced_vars": [ + "_t2", + "cost1" + ], + "range": { + "start": 129997, + "end": 129999 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "cost2.handle().eq(&_t3.handle_a1())", + "semantic_text": "cost2 == _t3.a1", + "referenced_vars": [ + "_t3", + "cost2" + ], + "range": { + "start": 130017, + "end": 130019 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 130037, + "end": 130039 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "cost1.handle().le(&cost2.handle())", + "semantic_text": "cost1 <= cost2", + "referenced_vars": [ + "cost1", + "cost2" + ], + "range": { + "start": 130057, + "end": 130059 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@236126:236189", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_operand_and_cost(pat.t1, ctx.devalue(pat.cost1))", + "semantic_text": null, + "referenced_pat_vars": [ + "cost1", + "t1" + ], + "referenced_action_vars": [], + "range": { + "start": 236126, + "end": 236189 + } + }, + { + "id": "effect_1", + "effect_id": "effect@236199:236221", + "bound_var": null, + "source_text": "ctx.union(pat.lhs, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 236199, + "end": 236221 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0150", + "premises": [ + { + "target_id": "cost1", + "label": "cost1: ", + "plain_source": "cost1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $]" + }, + { + "target_id": "cost2", + "label": "cost2: ", + "plain_source": "cost2", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSmaller", + "plain_source": "upright(\"Smaller\")(upright(\"_t2\"), upright(\"_t3\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Smaller\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxOperandAndCost", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxOperandAndCost", + "plain_source": "upright(\"_t3\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]" + } + ], + "side_conditions": [ + "upright(\"cost1\") == upright(\"_t2.a1\")", + "upright(\"cost2\") == upright(\"_t3.a1\")", + "upright(\"lhs\") == upright(\"_t1\")", + "upright(\"cost1\") <= upright(\"cost2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "t_1", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ t_1 $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "lhs", + "label": "lhs: EcxTermAndCost", + "plain_source": "upright(\"lhs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "t_1", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ t_1 $]" + } + } + ], + "formula_source": { + "plain": "frac(cost1 \\ cost2 \\ upright(\"Smaller\")(upright(\"_t2\"), upright(\"_t3\")) \\ upright(\"_t2\") \\ upright(\"_t3\"), upright(\"lhs\") arrow.r.double t_1) quad upright(\"if\") quad upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"cost2\") == upright(\"_t3.a1\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") <= upright(\"cost2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Smaller\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ t_1 $]) quad upright(\"if\") quad upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"cost2\") == upright(\"_t3.a1\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") <= upright(\"cost2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7500_5_MyTxEggccExtraction_add_rule__r0151__7a09eea0b792b95c", + "display_name": "r0151", + "rule_name": "r0151", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 236235, + "line": 7500, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 236235, + "end": 236426 + }, + "pattern_range": { + "start": 236280, + "end": 236291 + }, + "action_range": { + "start": 236293, + "end": 236425 + } + }, + "nodes": [ + { + "id": "cost1", + "kind": "query", + "dsl_type": "", + "label": "cost1: ", + "range": { + "start": 130348, + "end": 130401 + }, + "inputs": [] + }, + { + "id": "cost2", + "kind": "query", + "dsl_type": "", + "label": "cost2: ", + "range": { + "start": 130406, + "end": 130459 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxTermAndCost", + "label": "lhs: EcxTermAndCost", + "range": { + "start": 130464, + "end": 130503 + }, + "inputs": [] + }, + { + "id": "t1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "t1: EcxOperand", + "range": { + "start": 130508, + "end": 130542 + }, + "inputs": [] + }, + { + "id": "t2", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "t2: EcxOperand", + "range": { + "start": 130547, + "end": 130581 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxOperandAndCost", + "label": "_t2: EcxOperandAndCost", + "range": { + "start": 130586, + "end": 130626 + }, + "inputs": [ + "t1" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxOperandAndCost", + "label": "_t3: EcxOperandAndCost", + "range": { + "start": 130631, + "end": 130671 + }, + "inputs": [ + "t2" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSmaller", + "label": "_t1: EcxSmaller", + "range": { + "start": 130676, + "end": 130716 + }, + "inputs": [ + "_t2", + "_t3" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "t1", + "kind": "operand", + "index": 0 + }, + { + "from": "_t3", + "to": "t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t3", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cost1", + "cost2", + "lhs", + "t1", + "t2", + "_t1", + "_t2", + "_t3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "cost1.handle().eq(&_t2.handle_a1())", + "semantic_text": "cost1 == _t2.a1", + "referenced_vars": [ + "_t2", + "cost1" + ], + "range": { + "start": 130986, + "end": 130988 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "cost2.handle().eq(&_t3.handle_a1())", + "semantic_text": "cost2 == _t3.a1", + "referenced_vars": [ + "_t3", + "cost2" + ], + "range": { + "start": 131006, + "end": 131008 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 131026, + "end": 131028 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "cost1.handle().gt(&cost2.handle())", + "semantic_text": "cost1 > cost2", + "referenced_vars": [ + "cost1", + "cost2" + ], + "range": { + "start": 131046, + "end": 131048 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@236323:236386", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_operand_and_cost(pat.t2, ctx.devalue(pat.cost2))", + "semantic_text": null, + "referenced_pat_vars": [ + "cost2", + "t2" + ], + "referenced_action_vars": [], + "range": { + "start": 236323, + "end": 236386 + } + }, + { + "id": "effect_1", + "effect_id": "effect@236396:236418", + "bound_var": null, + "source_text": "ctx.union(pat.lhs, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 236396, + "end": 236418 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0151", + "premises": [ + { + "target_id": "cost1", + "label": "cost1: ", + "plain_source": "cost1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $]" + }, + { + "target_id": "cost2", + "label": "cost2: ", + "plain_source": "cost2", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSmaller", + "plain_source": "upright(\"Smaller\")(upright(\"_t2\"), upright(\"_t3\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Smaller\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxOperandAndCost", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxOperandAndCost", + "plain_source": "upright(\"_t3\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]" + } + ], + "side_conditions": [ + "upright(\"cost1\") == upright(\"_t2.a1\")", + "upright(\"cost2\") == upright(\"_t3.a1\")", + "upright(\"lhs\") == upright(\"_t1\")", + "upright(\"cost1\") > upright(\"cost2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"OperandAndCost\")(t_2, cost2)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandAndCost\")(#text(fill: rgb(\"#5F7A8A\"))[$ t_2 $], #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "lhs", + "label": "lhs: EcxTermAndCost", + "plain_source": "upright(\"lhs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"OperandAndCost\")(t_2, cost2)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandAndCost\")(#text(fill: rgb(\"#5F7A8A\"))[$ t_2 $], #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(cost1 \\ cost2 \\ upright(\"Smaller\")(upright(\"_t2\"), upright(\"_t3\")) \\ upright(\"_t2\") \\ upright(\"_t3\"), upright(\"lhs\") arrow.r.double upright(\"OperandAndCost\")(t_2, cost2)) quad upright(\"if\") quad upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"cost2\") == upright(\"_t3.a1\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") > upright(\"cost2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Smaller\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandAndCost\")(#text(fill: rgb(\"#5F7A8A\"))[$ t_2 $], #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]) $]) quad upright(\"if\") quad upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"cost2\") == upright(\"_t3.a1\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") > upright(\"cost2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7504_5_MyTxEggccExtraction_add_rule__r0152__af9f259be32dbbf9", + "display_name": "r0152", + "rule_name": "r0152", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 236432, + "line": 7504, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 236432, + "end": 236620 + }, + "pattern_range": { + "start": 236477, + "end": 236488 + }, + "action_range": { + "start": 236490, + "end": 236619 + } + }, + "nodes": [ + { + "id": "cost1", + "kind": "query", + "dsl_type": "", + "label": "cost1: ", + "range": { + "start": 131325, + "end": 131378 + }, + "inputs": [] + }, + { + "id": "cost2", + "kind": "query", + "dsl_type": "", + "label": "cost2: ", + "range": { + "start": 131383, + "end": 131436 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxTermAndCost", + "label": "lhs: EcxTermAndCost", + "range": { + "start": 131441, + "end": 131480 + }, + "inputs": [] + }, + { + "id": "t1", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "t1: EcxBody", + "range": { + "start": 131485, + "end": 131516 + }, + "inputs": [] + }, + { + "id": "t2", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "t2: EcxBody", + "range": { + "start": 131521, + "end": 131552 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxBodyAndCost", + "label": "_t2: EcxBodyAndCost", + "range": { + "start": 131557, + "end": 131594 + }, + "inputs": [ + "t1" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxBodyAndCost", + "label": "_t3: EcxBodyAndCost", + "range": { + "start": 131599, + "end": 131636 + }, + "inputs": [ + "t2" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSmaller", + "label": "_t1: EcxSmaller", + "range": { + "start": 131641, + "end": 131681 + }, + "inputs": [ + "_t2", + "_t3" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "t1", + "kind": "operand", + "index": 0 + }, + { + "from": "_t3", + "to": "t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t3", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cost1", + "cost2", + "lhs", + "t1", + "t2", + "_t1", + "_t2", + "_t3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "cost1.handle().eq(&_t2.handle_a1())", + "semantic_text": "cost1 == _t2.a1", + "referenced_vars": [ + "_t2", + "cost1" + ], + "range": { + "start": 131951, + "end": 131953 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "cost2.handle().eq(&_t3.handle_a1())", + "semantic_text": "cost2 == _t3.a1", + "referenced_vars": [ + "_t3", + "cost2" + ], + "range": { + "start": 131971, + "end": 131973 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 131991, + "end": 131993 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "cost1.handle().le(&cost2.handle())", + "semantic_text": "cost1 <= cost2", + "referenced_vars": [ + "cost1", + "cost2" + ], + "range": { + "start": 132011, + "end": 132013 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@236520:236580", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_body_and_cost(pat.t1, ctx.devalue(pat.cost1))", + "semantic_text": null, + "referenced_pat_vars": [ + "cost1", + "t1" + ], + "referenced_action_vars": [], + "range": { + "start": 236520, + "end": 236580 + } + }, + { + "id": "effect_1", + "effect_id": "effect@236590:236612", + "bound_var": null, + "source_text": "ctx.union(pat.lhs, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 236590, + "end": 236612 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0152", + "premises": [ + { + "target_id": "cost1", + "label": "cost1: ", + "plain_source": "cost1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $]" + }, + { + "target_id": "cost2", + "label": "cost2: ", + "plain_source": "cost2", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSmaller", + "plain_source": "upright(\"Smaller\")(upright(\"_t2\"), upright(\"_t3\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Smaller\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxBodyAndCost", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxBodyAndCost", + "plain_source": "upright(\"_t3\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]" + } + ], + "side_conditions": [ + "upright(\"cost1\") == upright(\"_t2.a1\")", + "upright(\"cost2\") == upright(\"_t3.a1\")", + "upright(\"lhs\") == upright(\"_t1\")", + "upright(\"cost1\") <= upright(\"cost2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "t_1", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ t_1 $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "lhs", + "label": "lhs: EcxTermAndCost", + "plain_source": "upright(\"lhs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "t_1", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ t_1 $]" + } + } + ], + "formula_source": { + "plain": "frac(cost1 \\ cost2 \\ upright(\"Smaller\")(upright(\"_t2\"), upright(\"_t3\")) \\ upright(\"_t2\") \\ upright(\"_t3\"), upright(\"lhs\") arrow.r.double t_1) quad upright(\"if\") quad upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"cost2\") == upright(\"_t3.a1\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") <= upright(\"cost2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Smaller\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ t_1 $]) quad upright(\"if\") quad upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"cost2\") == upright(\"_t3.a1\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") <= upright(\"cost2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7508_5_MyTxEggccExtraction_add_rule__r0153__429fe703d431235a", + "display_name": "r0153", + "rule_name": "r0153", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 236626, + "line": 7508, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 236626, + "end": 236814 + }, + "pattern_range": { + "start": 236671, + "end": 236682 + }, + "action_range": { + "start": 236684, + "end": 236813 + } + }, + "nodes": [ + { + "id": "cost1", + "kind": "query", + "dsl_type": "", + "label": "cost1: ", + "range": { + "start": 132290, + "end": 132343 + }, + "inputs": [] + }, + { + "id": "cost2", + "kind": "query", + "dsl_type": "", + "label": "cost2: ", + "range": { + "start": 132348, + "end": 132401 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxTermAndCost", + "label": "lhs: EcxTermAndCost", + "range": { + "start": 132406, + "end": 132445 + }, + "inputs": [] + }, + { + "id": "t1", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "t1: EcxBody", + "range": { + "start": 132450, + "end": 132481 + }, + "inputs": [] + }, + { + "id": "t2", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "t2: EcxBody", + "range": { + "start": 132486, + "end": 132517 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxBodyAndCost", + "label": "_t2: EcxBodyAndCost", + "range": { + "start": 132522, + "end": 132559 + }, + "inputs": [ + "t1" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxBodyAndCost", + "label": "_t3: EcxBodyAndCost", + "range": { + "start": 132564, + "end": 132601 + }, + "inputs": [ + "t2" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSmaller", + "label": "_t1: EcxSmaller", + "range": { + "start": 132606, + "end": 132646 + }, + "inputs": [ + "_t2", + "_t3" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "t1", + "kind": "operand", + "index": 0 + }, + { + "from": "_t3", + "to": "t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t3", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cost1", + "cost2", + "lhs", + "t1", + "t2", + "_t1", + "_t2", + "_t3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "cost1.handle().eq(&_t2.handle_a1())", + "semantic_text": "cost1 == _t2.a1", + "referenced_vars": [ + "_t2", + "cost1" + ], + "range": { + "start": 132916, + "end": 132918 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "cost2.handle().eq(&_t3.handle_a1())", + "semantic_text": "cost2 == _t3.a1", + "referenced_vars": [ + "_t3", + "cost2" + ], + "range": { + "start": 132936, + "end": 132938 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 132956, + "end": 132958 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "cost1.handle().gt(&cost2.handle())", + "semantic_text": "cost1 > cost2", + "referenced_vars": [ + "cost1", + "cost2" + ], + "range": { + "start": 132976, + "end": 132978 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@236714:236774", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_body_and_cost(pat.t2, ctx.devalue(pat.cost2))", + "semantic_text": null, + "referenced_pat_vars": [ + "cost2", + "t2" + ], + "referenced_action_vars": [], + "range": { + "start": 236714, + "end": 236774 + } + }, + { + "id": "effect_1", + "effect_id": "effect@236784:236806", + "bound_var": null, + "source_text": "ctx.union(pat.lhs, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 236784, + "end": 236806 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0153", + "premises": [ + { + "target_id": "cost1", + "label": "cost1: ", + "plain_source": "cost1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $]" + }, + { + "target_id": "cost2", + "label": "cost2: ", + "plain_source": "cost2", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSmaller", + "plain_source": "upright(\"Smaller\")(upright(\"_t2\"), upright(\"_t3\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Smaller\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxBodyAndCost", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxBodyAndCost", + "plain_source": "upright(\"_t3\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]" + } + ], + "side_conditions": [ + "upright(\"cost1\") == upright(\"_t2.a1\")", + "upright(\"cost2\") == upright(\"_t3.a1\")", + "upright(\"lhs\") == upright(\"_t1\")", + "upright(\"cost1\") > upright(\"cost2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"BodyAndCost\")(t_2, cost2)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"BodyAndCost\")(#text(fill: rgb(\"#5F7A8A\"))[$ t_2 $], #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "lhs", + "label": "lhs: EcxTermAndCost", + "plain_source": "upright(\"lhs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"BodyAndCost\")(t_2, cost2)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"BodyAndCost\")(#text(fill: rgb(\"#5F7A8A\"))[$ t_2 $], #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(cost1 \\ cost2 \\ upright(\"Smaller\")(upright(\"_t2\"), upright(\"_t3\")) \\ upright(\"_t2\") \\ upright(\"_t3\"), upright(\"lhs\") arrow.r.double upright(\"BodyAndCost\")(t_2, cost2)) quad upright(\"if\") quad upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"cost2\") == upright(\"_t3.a1\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") > upright(\"cost2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Smaller\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"BodyAndCost\")(#text(fill: rgb(\"#5F7A8A\"))[$ t_2 $], #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]) $]) quad upright(\"if\") quad upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"cost2\") == upright(\"_t3.a1\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") > upright(\"cost2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7512_5_MyTxEggccExtraction_add_rule__r0154__d52c959992a5ccb8", + "display_name": "r0154", + "rule_name": "r0154", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 236820, + "line": 7512, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 236820, + "end": 237015 + }, + "pattern_range": { + "start": 236865, + "end": 236876 + }, + "action_range": { + "start": 236878, + "end": 237014 + } + }, + "nodes": [ + { + "id": "cost1", + "kind": "query", + "dsl_type": "", + "label": "cost1: ", + "range": { + "start": 133279, + "end": 133332 + }, + "inputs": [] + }, + { + "id": "cost2", + "kind": "query", + "dsl_type": "", + "label": "cost2: ", + "range": { + "start": 133337, + "end": 133390 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxTermAndCost", + "label": "lhs: EcxTermAndCost", + "range": { + "start": 133395, + "end": 133434 + }, + "inputs": [] + }, + { + "id": "t1", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "t1: EcxVecOperand", + "range": { + "start": 133439, + "end": 133476 + }, + "inputs": [] + }, + { + "id": "t2", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "t2: EcxVecOperand", + "range": { + "start": 133481, + "end": 133518 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVecOperandAndCost", + "label": "_t2: EcxVecOperandAndCost", + "range": { + "start": 133523, + "end": 133566 + }, + "inputs": [ + "t1" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxVecOperandAndCost", + "label": "_t3: EcxVecOperandAndCost", + "range": { + "start": 133571, + "end": 133614 + }, + "inputs": [ + "t2" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSmaller", + "label": "_t1: EcxSmaller", + "range": { + "start": 133619, + "end": 133659 + }, + "inputs": [ + "_t2", + "_t3" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "t1", + "kind": "operand", + "index": 0 + }, + { + "from": "_t3", + "to": "t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t3", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cost1", + "cost2", + "lhs", + "t1", + "t2", + "_t1", + "_t2", + "_t3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "cost1.handle().eq(&_t2.handle_a1())", + "semantic_text": "cost1 == _t2.a1", + "referenced_vars": [ + "_t2", + "cost1" + ], + "range": { + "start": 133929, + "end": 133931 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "cost2.handle().eq(&_t3.handle_a1())", + "semantic_text": "cost2 == _t3.a1", + "referenced_vars": [ + "_t3", + "cost2" + ], + "range": { + "start": 133949, + "end": 133951 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 133969, + "end": 133971 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "cost1.handle().le(&cost2.handle())", + "semantic_text": "cost1 <= cost2", + "referenced_vars": [ + "cost1", + "cost2" + ], + "range": { + "start": 133989, + "end": 133991 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@236908:236975", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_vec_operand_and_cost(pat.t1, ctx.devalue(pat.cost1))", + "semantic_text": null, + "referenced_pat_vars": [ + "cost1", + "t1" + ], + "referenced_action_vars": [], + "range": { + "start": 236908, + "end": 236975 + } + }, + { + "id": "effect_1", + "effect_id": "effect@236985:237007", + "bound_var": null, + "source_text": "ctx.union(pat.lhs, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 236985, + "end": 237007 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0154", + "premises": [ + { + "target_id": "cost1", + "label": "cost1: ", + "plain_source": "cost1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $]" + }, + { + "target_id": "cost2", + "label": "cost2: ", + "plain_source": "cost2", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSmaller", + "plain_source": "upright(\"Smaller\")(upright(\"_t2\"), upright(\"_t3\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Smaller\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVecOperandAndCost", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxVecOperandAndCost", + "plain_source": "upright(\"_t3\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]" + } + ], + "side_conditions": [ + "upright(\"cost1\") == upright(\"_t2.a1\")", + "upright(\"cost2\") == upright(\"_t3.a1\")", + "upright(\"lhs\") == upright(\"_t1\")", + "upright(\"cost1\") <= upright(\"cost2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "t_1", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ t_1 $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "lhs", + "label": "lhs: EcxTermAndCost", + "plain_source": "upright(\"lhs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "t_1", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ t_1 $]" + } + } + ], + "formula_source": { + "plain": "frac(cost1 \\ cost2 \\ upright(\"Smaller\")(upright(\"_t2\"), upright(\"_t3\")) \\ upright(\"_t2\") \\ upright(\"_t3\"), upright(\"lhs\") arrow.r.double t_1) quad upright(\"if\") quad upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"cost2\") == upright(\"_t3.a1\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") <= upright(\"cost2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Smaller\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ t_1 $]) quad upright(\"if\") quad upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"cost2\") == upright(\"_t3.a1\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") <= upright(\"cost2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7516_5_MyTxEggccExtraction_add_rule__r0155__2eb72996251f526f", + "display_name": "r0155", + "rule_name": "r0155", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 237021, + "line": 7516, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 237021, + "end": 237216 + }, + "pattern_range": { + "start": 237066, + "end": 237077 + }, + "action_range": { + "start": 237079, + "end": 237215 + } + }, + "nodes": [ + { + "id": "cost1", + "kind": "query", + "dsl_type": "", + "label": "cost1: ", + "range": { + "start": 134292, + "end": 134345 + }, + "inputs": [] + }, + { + "id": "cost2", + "kind": "query", + "dsl_type": "", + "label": "cost2: ", + "range": { + "start": 134350, + "end": 134403 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxTermAndCost", + "label": "lhs: EcxTermAndCost", + "range": { + "start": 134408, + "end": 134447 + }, + "inputs": [] + }, + { + "id": "t1", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "t1: EcxVecOperand", + "range": { + "start": 134452, + "end": 134489 + }, + "inputs": [] + }, + { + "id": "t2", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "t2: EcxVecOperand", + "range": { + "start": 134494, + "end": 134531 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVecOperandAndCost", + "label": "_t2: EcxVecOperandAndCost", + "range": { + "start": 134536, + "end": 134579 + }, + "inputs": [ + "t1" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxVecOperandAndCost", + "label": "_t3: EcxVecOperandAndCost", + "range": { + "start": 134584, + "end": 134627 + }, + "inputs": [ + "t2" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSmaller", + "label": "_t1: EcxSmaller", + "range": { + "start": 134632, + "end": 134672 + }, + "inputs": [ + "_t2", + "_t3" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "t1", + "kind": "operand", + "index": 0 + }, + { + "from": "_t3", + "to": "t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t3", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cost1", + "cost2", + "lhs", + "t1", + "t2", + "_t1", + "_t2", + "_t3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "cost1.handle().eq(&_t2.handle_a1())", + "semantic_text": "cost1 == _t2.a1", + "referenced_vars": [ + "_t2", + "cost1" + ], + "range": { + "start": 134942, + "end": 134944 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "cost2.handle().eq(&_t3.handle_a1())", + "semantic_text": "cost2 == _t3.a1", + "referenced_vars": [ + "_t3", + "cost2" + ], + "range": { + "start": 134962, + "end": 134964 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 134982, + "end": 134984 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "cost1.handle().gt(&cost2.handle())", + "semantic_text": "cost1 > cost2", + "referenced_vars": [ + "cost1", + "cost2" + ], + "range": { + "start": 135002, + "end": 135004 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@237109:237176", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_vec_operand_and_cost(pat.t2, ctx.devalue(pat.cost2))", + "semantic_text": null, + "referenced_pat_vars": [ + "cost2", + "t2" + ], + "referenced_action_vars": [], + "range": { + "start": 237109, + "end": 237176 + } + }, + { + "id": "effect_1", + "effect_id": "effect@237186:237208", + "bound_var": null, + "source_text": "ctx.union(pat.lhs, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 237186, + "end": 237208 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0155", + "premises": [ + { + "target_id": "cost1", + "label": "cost1: ", + "plain_source": "cost1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $]" + }, + { + "target_id": "cost2", + "label": "cost2: ", + "plain_source": "cost2", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSmaller", + "plain_source": "upright(\"Smaller\")(upright(\"_t2\"), upright(\"_t3\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Smaller\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVecOperandAndCost", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxVecOperandAndCost", + "plain_source": "upright(\"_t3\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]" + } + ], + "side_conditions": [ + "upright(\"cost1\") == upright(\"_t2.a1\")", + "upright(\"cost2\") == upright(\"_t3.a1\")", + "upright(\"lhs\") == upright(\"_t1\")", + "upright(\"cost1\") > upright(\"cost2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"VecOperandAndCost\")(t_2, cost2)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"VecOperandAndCost\")(#text(fill: rgb(\"#5F7A8A\"))[$ t_2 $], #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "lhs", + "label": "lhs: EcxTermAndCost", + "plain_source": "upright(\"lhs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"VecOperandAndCost\")(t_2, cost2)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"VecOperandAndCost\")(#text(fill: rgb(\"#5F7A8A\"))[$ t_2 $], #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(cost1 \\ cost2 \\ upright(\"Smaller\")(upright(\"_t2\"), upright(\"_t3\")) \\ upright(\"_t2\") \\ upright(\"_t3\"), upright(\"lhs\") arrow.r.double upright(\"VecOperandAndCost\")(t_2, cost2)) quad upright(\"if\") quad upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"cost2\") == upright(\"_t3.a1\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") > upright(\"cost2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Smaller\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"VecOperandAndCost\")(#text(fill: rgb(\"#5F7A8A\"))[$ t_2 $], #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]) $]) quad upright(\"if\") quad upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"cost2\") == upright(\"_t3.a1\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") > upright(\"cost2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7520_5_MyTxEggccExtraction_add_rule__r0156__2d7be3bdde013cbf", + "display_name": "r0156", + "rule_name": "r0156", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 237222, + "line": 7520, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 237222, + "end": 237421 + }, + "pattern_range": { + "start": 237267, + "end": 237278 + }, + "action_range": { + "start": 237280, + "end": 237420 + } + }, + "nodes": [ + { + "id": "cost1", + "kind": "query", + "dsl_type": "", + "label": "cost1: ", + "range": { + "start": 135317, + "end": 135370 + }, + "inputs": [] + }, + { + "id": "cost2", + "kind": "query", + "dsl_type": "", + "label": "cost2: ", + "range": { + "start": 135375, + "end": 135428 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxTermAndCost", + "label": "lhs: EcxTermAndCost", + "range": { + "start": 135433, + "end": 135472 + }, + "inputs": [] + }, + { + "id": "t1", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "t1: EcxVecVecOperand", + "range": { + "start": 135477, + "end": 135517 + }, + "inputs": [] + }, + { + "id": "t2", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "t2: EcxVecVecOperand", + "range": { + "start": 135522, + "end": 135562 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVecVecOperandAndCost", + "label": "_t2: EcxVecVecOperandAndCost", + "range": { + "start": 135567, + "end": 135613 + }, + "inputs": [ + "t1" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxVecVecOperandAndCost", + "label": "_t3: EcxVecVecOperandAndCost", + "range": { + "start": 135618, + "end": 135664 + }, + "inputs": [ + "t2" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSmaller", + "label": "_t1: EcxSmaller", + "range": { + "start": 135669, + "end": 135709 + }, + "inputs": [ + "_t2", + "_t3" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "t1", + "kind": "operand", + "index": 0 + }, + { + "from": "_t3", + "to": "t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t3", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cost1", + "cost2", + "lhs", + "t1", + "t2", + "_t1", + "_t2", + "_t3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "cost1.handle().eq(&_t2.handle_a1())", + "semantic_text": "cost1 == _t2.a1", + "referenced_vars": [ + "_t2", + "cost1" + ], + "range": { + "start": 135979, + "end": 135981 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "cost2.handle().eq(&_t3.handle_a1())", + "semantic_text": "cost2 == _t3.a1", + "referenced_vars": [ + "_t3", + "cost2" + ], + "range": { + "start": 135999, + "end": 136001 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 136019, + "end": 136021 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "cost1.handle().le(&cost2.handle())", + "semantic_text": "cost1 <= cost2", + "referenced_vars": [ + "cost1", + "cost2" + ], + "range": { + "start": 136039, + "end": 136041 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@237310:237381", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_vec_vec_operand_and_cost(pat.t1, ctx.devalue(pat.cost1))", + "semantic_text": null, + "referenced_pat_vars": [ + "cost1", + "t1" + ], + "referenced_action_vars": [], + "range": { + "start": 237310, + "end": 237381 + } + }, + { + "id": "effect_1", + "effect_id": "effect@237391:237413", + "bound_var": null, + "source_text": "ctx.union(pat.lhs, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 237391, + "end": 237413 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0156", + "premises": [ + { + "target_id": "cost1", + "label": "cost1: ", + "plain_source": "cost1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $]" + }, + { + "target_id": "cost2", + "label": "cost2: ", + "plain_source": "cost2", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSmaller", + "plain_source": "upright(\"Smaller\")(upright(\"_t2\"), upright(\"_t3\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Smaller\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVecVecOperandAndCost", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxVecVecOperandAndCost", + "plain_source": "upright(\"_t3\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]" + } + ], + "side_conditions": [ + "upright(\"cost1\") == upright(\"_t2.a1\")", + "upright(\"cost2\") == upright(\"_t3.a1\")", + "upright(\"lhs\") == upright(\"_t1\")", + "upright(\"cost1\") <= upright(\"cost2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "t_1", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ t_1 $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "lhs", + "label": "lhs: EcxTermAndCost", + "plain_source": "upright(\"lhs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "t_1", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ t_1 $]" + } + } + ], + "formula_source": { + "plain": "frac(cost1 \\ cost2 \\ upright(\"Smaller\")(upright(\"_t2\"), upright(\"_t3\")) \\ upright(\"_t2\") \\ upright(\"_t3\"), upright(\"lhs\") arrow.r.double t_1) quad upright(\"if\") quad upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"cost2\") == upright(\"_t3.a1\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") <= upright(\"cost2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Smaller\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ t_1 $]) quad upright(\"if\") quad upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"cost2\") == upright(\"_t3.a1\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") <= upright(\"cost2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7524_5_MyTxEggccExtraction_add_rule__r0157__313a780c858dc340", + "display_name": "r0157", + "rule_name": "r0157", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 237427, + "line": 7524, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 237427, + "end": 237626 + }, + "pattern_range": { + "start": 237472, + "end": 237483 + }, + "action_range": { + "start": 237485, + "end": 237625 + } + }, + "nodes": [ + { + "id": "cost1", + "kind": "query", + "dsl_type": "", + "label": "cost1: ", + "range": { + "start": 136354, + "end": 136407 + }, + "inputs": [] + }, + { + "id": "cost2", + "kind": "query", + "dsl_type": "", + "label": "cost2: ", + "range": { + "start": 136412, + "end": 136465 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxTermAndCost", + "label": "lhs: EcxTermAndCost", + "range": { + "start": 136470, + "end": 136509 + }, + "inputs": [] + }, + { + "id": "t1", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "t1: EcxVecVecOperand", + "range": { + "start": 136514, + "end": 136554 + }, + "inputs": [] + }, + { + "id": "t2", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "t2: EcxVecVecOperand", + "range": { + "start": 136559, + "end": 136599 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVecVecOperandAndCost", + "label": "_t2: EcxVecVecOperandAndCost", + "range": { + "start": 136604, + "end": 136650 + }, + "inputs": [ + "t1" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxVecVecOperandAndCost", + "label": "_t3: EcxVecVecOperandAndCost", + "range": { + "start": 136655, + "end": 136701 + }, + "inputs": [ + "t2" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxSmaller", + "label": "_t1: EcxSmaller", + "range": { + "start": 136706, + "end": 136746 + }, + "inputs": [ + "_t2", + "_t3" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "t1", + "kind": "operand", + "index": 0 + }, + { + "from": "_t3", + "to": "t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t3", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "cost1", + "cost2", + "lhs", + "t1", + "t2", + "_t1", + "_t2", + "_t3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "cost1.handle().eq(&_t2.handle_a1())", + "semantic_text": "cost1 == _t2.a1", + "referenced_vars": [ + "_t2", + "cost1" + ], + "range": { + "start": 137016, + "end": 137018 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "cost2.handle().eq(&_t3.handle_a1())", + "semantic_text": "cost2 == _t3.a1", + "referenced_vars": [ + "_t3", + "cost2" + ], + "range": { + "start": 137036, + "end": 137038 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 137056, + "end": 137058 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "cost1.handle().gt(&cost2.handle())", + "semantic_text": "cost1 > cost2", + "referenced_vars": [ + "cost1", + "cost2" + ], + "range": { + "start": 137076, + "end": 137078 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@237515:237586", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_vec_vec_operand_and_cost(pat.t2, ctx.devalue(pat.cost2))", + "semantic_text": null, + "referenced_pat_vars": [ + "cost2", + "t2" + ], + "referenced_action_vars": [], + "range": { + "start": 237515, + "end": 237586 + } + }, + { + "id": "effect_1", + "effect_id": "effect@237596:237618", + "bound_var": null, + "source_text": "ctx.union(pat.lhs, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 237596, + "end": 237618 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0157", + "premises": [ + { + "target_id": "cost1", + "label": "cost1: ", + "plain_source": "cost1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $]" + }, + { + "target_id": "cost2", + "label": "cost2: ", + "plain_source": "cost2", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxSmaller", + "plain_source": "upright(\"Smaller\")(upright(\"_t2\"), upright(\"_t3\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Smaller\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVecVecOperandAndCost", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxVecVecOperandAndCost", + "plain_source": "upright(\"_t3\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]" + } + ], + "side_conditions": [ + "upright(\"cost1\") == upright(\"_t2.a1\")", + "upright(\"cost2\") == upright(\"_t3.a1\")", + "upright(\"lhs\") == upright(\"_t1\")", + "upright(\"cost1\") > upright(\"cost2\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"VecVecOperandAndCost\")(t_2, cost2)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"VecVecOperandAndCost\")(#text(fill: rgb(\"#5F7A8A\"))[$ t_2 $], #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "lhs", + "label": "lhs: EcxTermAndCost", + "plain_source": "upright(\"lhs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"VecVecOperandAndCost\")(t_2, cost2)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"VecVecOperandAndCost\")(#text(fill: rgb(\"#5F7A8A\"))[$ t_2 $], #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(cost1 \\ cost2 \\ upright(\"Smaller\")(upright(\"_t2\"), upright(\"_t3\")) \\ upright(\"_t2\") \\ upright(\"_t3\"), upright(\"lhs\") arrow.r.double upright(\"VecVecOperandAndCost\")(t_2, cost2)) quad upright(\"if\") quad upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"cost2\") == upright(\"_t3.a1\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") > upright(\"cost2\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Smaller\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"VecVecOperandAndCost\")(#text(fill: rgb(\"#5F7A8A\"))[$ t_2 $], #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]) $]) quad upright(\"if\") quad upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"cost2\") == upright(\"_t3.a1\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") > upright(\"cost2\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7528_5_MyTxEggccExtraction_add_rule__r0158__01de65effb966649", + "display_name": "r0158", + "rule_name": "r0158", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 237632, + "line": 7528, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 237632, + "end": 237972 + }, + "pattern_range": { + "start": 237677, + "end": 237688 + }, + "action_range": { + "start": 237690, + "end": 237971 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 137468, + "end": 137501 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 137506, + "end": 137539 + }, + "inputs": [] + }, + { + "id": "cost1", + "kind": "query", + "dsl_type": "", + "label": "cost1: ", + "range": { + "start": 137544, + "end": 137597 + }, + "inputs": [] + }, + { + "id": "cost2", + "kind": "query", + "dsl_type": "", + "label": "cost2: ", + "range": { + "start": 137602, + "end": 137655 + }, + "inputs": [] + }, + { + "id": "expr1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "expr1: EcxOperand", + "range": { + "start": 137660, + "end": 137697 + }, + "inputs": [] + }, + { + "id": "expr2", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "expr2: EcxOperand", + "range": { + "start": 137702, + "end": 137739 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "lhs: EcxExpr", + "range": { + "start": 137744, + "end": 137776 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty: EcxType", + "range": { + "start": 137781, + "end": 137812 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "Ecxbadd", + "label": "_t1: Ecxbadd", + "range": { + "start": 137817, + "end": 137855 + }, + "inputs": [ + "ty", + "a", + "b" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxOperandAndCost", + "label": "_t2: EcxOperandAndCost", + "range": { + "start": 137860, + "end": 137903 + }, + "inputs": [ + "expr1" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxExtractedOperand", + "label": "_f3: EcxExtractedOperand", + "range": { + "start": 137908, + "end": 137949 + }, + "inputs": [ + "a" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxOperandAndCost", + "label": "_t4: EcxOperandAndCost", + "range": { + "start": 137954, + "end": 137997 + }, + "inputs": [ + "expr2" + ] + }, + { + "id": "_f5", + "kind": "query", + "dsl_type": "EcxExtractedOperand", + "label": "_f5: EcxExtractedOperand", + "range": { + "start": 138002, + "end": 138043 + }, + "inputs": [ + "b" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "a", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "b", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "expr1", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "a", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "expr2", + "kind": "operand", + "index": 0 + }, + { + "from": "_f5", + "to": "b", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "a", + "b", + "cost1", + "cost2", + "expr1", + "expr2", + "lhs", + "ty", + "_t1", + "_t2", + "_f3", + "_t4", + "_f5" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 138391, + "end": 138393 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "cost1.handle().eq(&_t2.handle_a1())", + "semantic_text": "cost1 == _t2.a1", + "referenced_vars": [ + "_t2", + "cost1" + ], + "range": { + "start": 138407, + "end": 138409 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "_t2.handle().eq(&_f3.handle())", + "semantic_text": "_t2 == _f3", + "referenced_vars": [ + "_f3", + "_t2" + ], + "range": { + "start": 138423, + "end": 138425 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "cost2.handle().eq(&_t4.handle_a1())", + "semantic_text": "cost2 == _t4.a1", + "referenced_vars": [ + "_t4", + "cost2" + ], + "range": { + "start": 138439, + "end": 138441 + } + }, + { + "id": "constraint_4", + "source_text": "c4", + "resolved_text": "_t4.handle().eq(&_f5.handle())", + "semantic_text": "_t4 == _f5", + "referenced_vars": [ + "_f5", + "_t4" + ], + "range": { + "start": 138455, + "end": 138457 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@237720:237768", + "bound_var": "t2", + "source_text": "ctx.insert_ecxbadd(pat.ty, pat.expr1, pat.expr2)", + "semantic_text": null, + "referenced_pat_vars": [ + "expr1", + "expr2", + "ty" + ], + "referenced_action_vars": [], + "range": { + "start": 237720, + "end": 237768 + } + }, + { + "id": "effect_1", + "effect_id": "effect@237787:237915", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_expr_and_cost(\n t2,\n (1_i64 + (ctx.devalue(pat.cost1) + ctx.devalue(pat.cost2))),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "cost1", + "cost2" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 237787, + "end": 237915 + } + }, + { + "id": "effect_2", + "effect_id": "effect@237925:237964", + "bound_var": null, + "source_text": "ctx.set_ecx_extracted_expr(pat.lhs, t1)", + "semantic_text": "ecx_extracted_expr(pat.lhs) = t1", + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 237925, + "end": 237964 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0158", + "premises": [ + { + "target_id": "cost1", + "label": "cost1: ", + "plain_source": "cost1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $]" + }, + { + "target_id": "cost2", + "label": "cost2: ", + "plain_source": "cost2", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]" + }, + { + "target_id": "_t1", + "label": "_t1: Ecxbadd", + "plain_source": "upright(\"badd\")(upright(\"ty\"), a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxOperandAndCost", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxExtractedOperand", + "plain_source": "upright(\"EcxExtractedOperand\")(a)", + "colored_source": "upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxOperandAndCost", + "plain_source": "upright(\"_t4\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $]" + }, + { + "target_id": "_f5", + "label": "_f5: EcxExtractedOperand", + "plain_source": "upright(\"EcxExtractedOperand\")(b)", + "colored_source": "upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $])" + } + ], + "side_conditions": [ + "upright(\"lhs\") == upright(\"_t1\")", + "upright(\"cost1\") == upright(\"_t2.a1\")", + "upright(\"_t2\") == upright(\"_f3\")", + "upright(\"cost2\") == upright(\"_t4.a1\")", + "upright(\"_t4\") == upright(\"_f5\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_2", + "entry": { + "target_id": "effect:effect_2", + "label": "effect_2", + "plain_source": "upright(\"ecx_extracted_expr\")(upright(\"lhs\")) = upright(\"ExprAndCost\")((upright(\"badd\")(upright(\"ty\"), expr1, expr2)), 1 + upright(\"cost1\") + upright(\"cost2\"))", + "colored_source": "upright(\"ecx_extracted_expr\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"ExprAndCost\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ expr1 $], #text(fill: rgb(\"#5F7A8A\"))[$ expr2 $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ 1 + upright(\"cost1\") + upright(\"cost2\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(cost1 \\ cost2 \\ upright(\"badd\")(upright(\"ty\"), a, b) \\ upright(\"_t2\") \\ upright(\"EcxExtractedOperand\")(a) \\ upright(\"_t4\") \\ upright(\"EcxExtractedOperand\")(b), upright(\"ecx_extracted_expr\")(upright(\"lhs\")) = upright(\"ExprAndCost\")((upright(\"badd\")(upright(\"ty\"), expr1, expr2)), 1 + upright(\"cost1\") + upright(\"cost2\"))) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\") \\ upright(\"cost2\") == upright(\"_t4.a1\") \\ upright(\"_t4\") == upright(\"_f5\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $] \\ upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $]), upright(\"ecx_extracted_expr\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"ExprAndCost\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ expr1 $], #text(fill: rgb(\"#5F7A8A\"))[$ expr2 $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ 1 + upright(\"cost1\") + upright(\"cost2\") $]) $]) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\") \\ upright(\"cost2\") == upright(\"_t4.a1\") \\ upright(\"_t4\") == upright(\"_f5\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7536_5_MyTxEggccExtraction_add_rule__r0159__4283179806a00211", + "display_name": "r0159", + "rule_name": "r0159", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 237978, + "line": 7536, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 237978, + "end": 238318 + }, + "pattern_range": { + "start": 238023, + "end": 238034 + }, + "action_range": { + "start": 238036, + "end": 238317 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 138847, + "end": 138880 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 138885, + "end": 138918 + }, + "inputs": [] + }, + { + "id": "cost1", + "kind": "query", + "dsl_type": "", + "label": "cost1: ", + "range": { + "start": 138923, + "end": 138976 + }, + "inputs": [] + }, + { + "id": "cost2", + "kind": "query", + "dsl_type": "", + "label": "cost2: ", + "range": { + "start": 138981, + "end": 139034 + }, + "inputs": [] + }, + { + "id": "expr1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "expr1: EcxOperand", + "range": { + "start": 139039, + "end": 139076 + }, + "inputs": [] + }, + { + "id": "expr2", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "expr2: EcxOperand", + "range": { + "start": 139081, + "end": 139118 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "lhs: EcxExpr", + "range": { + "start": 139123, + "end": 139155 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty: EcxType", + "range": { + "start": 139160, + "end": 139191 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "Ecxbsub", + "label": "_t1: Ecxbsub", + "range": { + "start": 139196, + "end": 139234 + }, + "inputs": [ + "ty", + "a", + "b" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxOperandAndCost", + "label": "_t2: EcxOperandAndCost", + "range": { + "start": 139239, + "end": 139282 + }, + "inputs": [ + "expr1" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxExtractedOperand", + "label": "_f3: EcxExtractedOperand", + "range": { + "start": 139287, + "end": 139328 + }, + "inputs": [ + "a" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxOperandAndCost", + "label": "_t4: EcxOperandAndCost", + "range": { + "start": 139333, + "end": 139376 + }, + "inputs": [ + "expr2" + ] + }, + { + "id": "_f5", + "kind": "query", + "dsl_type": "EcxExtractedOperand", + "label": "_f5: EcxExtractedOperand", + "range": { + "start": 139381, + "end": 139422 + }, + "inputs": [ + "b" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "a", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "b", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "expr1", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "a", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "expr2", + "kind": "operand", + "index": 0 + }, + { + "from": "_f5", + "to": "b", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "a", + "b", + "cost1", + "cost2", + "expr1", + "expr2", + "lhs", + "ty", + "_t1", + "_t2", + "_f3", + "_t4", + "_f5" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 139770, + "end": 139772 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "cost1.handle().eq(&_t2.handle_a1())", + "semantic_text": "cost1 == _t2.a1", + "referenced_vars": [ + "_t2", + "cost1" + ], + "range": { + "start": 139786, + "end": 139788 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "_t2.handle().eq(&_f3.handle())", + "semantic_text": "_t2 == _f3", + "referenced_vars": [ + "_f3", + "_t2" + ], + "range": { + "start": 139802, + "end": 139804 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "cost2.handle().eq(&_t4.handle_a1())", + "semantic_text": "cost2 == _t4.a1", + "referenced_vars": [ + "_t4", + "cost2" + ], + "range": { + "start": 139818, + "end": 139820 + } + }, + { + "id": "constraint_4", + "source_text": "c4", + "resolved_text": "_t4.handle().eq(&_f5.handle())", + "semantic_text": "_t4 == _f5", + "referenced_vars": [ + "_f5", + "_t4" + ], + "range": { + "start": 139834, + "end": 139836 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@238066:238114", + "bound_var": "t2", + "source_text": "ctx.insert_ecxbsub(pat.ty, pat.expr1, pat.expr2)", + "semantic_text": null, + "referenced_pat_vars": [ + "expr1", + "expr2", + "ty" + ], + "referenced_action_vars": [], + "range": { + "start": 238066, + "end": 238114 + } + }, + { + "id": "effect_1", + "effect_id": "effect@238133:238261", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_expr_and_cost(\n t2,\n (1_i64 + (ctx.devalue(pat.cost1) + ctx.devalue(pat.cost2))),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "cost1", + "cost2" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 238133, + "end": 238261 + } + }, + { + "id": "effect_2", + "effect_id": "effect@238271:238310", + "bound_var": null, + "source_text": "ctx.set_ecx_extracted_expr(pat.lhs, t1)", + "semantic_text": "ecx_extracted_expr(pat.lhs) = t1", + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 238271, + "end": 238310 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0159", + "premises": [ + { + "target_id": "cost1", + "label": "cost1: ", + "plain_source": "cost1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $]" + }, + { + "target_id": "cost2", + "label": "cost2: ", + "plain_source": "cost2", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]" + }, + { + "target_id": "_t1", + "label": "_t1: Ecxbsub", + "plain_source": "upright(\"bsub\")(upright(\"ty\"), a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxOperandAndCost", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxExtractedOperand", + "plain_source": "upright(\"EcxExtractedOperand\")(a)", + "colored_source": "upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxOperandAndCost", + "plain_source": "upright(\"_t4\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $]" + }, + { + "target_id": "_f5", + "label": "_f5: EcxExtractedOperand", + "plain_source": "upright(\"EcxExtractedOperand\")(b)", + "colored_source": "upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $])" + } + ], + "side_conditions": [ + "upright(\"lhs\") == upright(\"_t1\")", + "upright(\"cost1\") == upright(\"_t2.a1\")", + "upright(\"_t2\") == upright(\"_f3\")", + "upright(\"cost2\") == upright(\"_t4.a1\")", + "upright(\"_t4\") == upright(\"_f5\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_2", + "entry": { + "target_id": "effect:effect_2", + "label": "effect_2", + "plain_source": "upright(\"ecx_extracted_expr\")(upright(\"lhs\")) = upright(\"ExprAndCost\")((upright(\"bsub\")(upright(\"ty\"), expr1, expr2)), 1 + upright(\"cost1\") + upright(\"cost2\"))", + "colored_source": "upright(\"ecx_extracted_expr\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"ExprAndCost\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ expr1 $], #text(fill: rgb(\"#5F7A8A\"))[$ expr2 $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ 1 + upright(\"cost1\") + upright(\"cost2\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(cost1 \\ cost2 \\ upright(\"bsub\")(upright(\"ty\"), a, b) \\ upright(\"_t2\") \\ upright(\"EcxExtractedOperand\")(a) \\ upright(\"_t4\") \\ upright(\"EcxExtractedOperand\")(b), upright(\"ecx_extracted_expr\")(upright(\"lhs\")) = upright(\"ExprAndCost\")((upright(\"bsub\")(upright(\"ty\"), expr1, expr2)), 1 + upright(\"cost1\") + upright(\"cost2\"))) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\") \\ upright(\"cost2\") == upright(\"_t4.a1\") \\ upright(\"_t4\") == upright(\"_f5\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $] \\ upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $]), upright(\"ecx_extracted_expr\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"ExprAndCost\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bsub\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ expr1 $], #text(fill: rgb(\"#5F7A8A\"))[$ expr2 $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ 1 + upright(\"cost1\") + upright(\"cost2\") $]) $]) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\") \\ upright(\"cost2\") == upright(\"_t4.a1\") \\ upright(\"_t4\") == upright(\"_f5\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7544_5_MyTxEggccExtraction_add_rule__r0160__28410f519e264464", + "display_name": "r0160", + "rule_name": "r0160", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 238324, + "line": 7544, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 238324, + "end": 238664 + }, + "pattern_range": { + "start": 238369, + "end": 238380 + }, + "action_range": { + "start": 238382, + "end": 238663 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 140226, + "end": 140259 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 140264, + "end": 140297 + }, + "inputs": [] + }, + { + "id": "cost1", + "kind": "query", + "dsl_type": "", + "label": "cost1: ", + "range": { + "start": 140302, + "end": 140355 + }, + "inputs": [] + }, + { + "id": "cost2", + "kind": "query", + "dsl_type": "", + "label": "cost2: ", + "range": { + "start": 140360, + "end": 140413 + }, + "inputs": [] + }, + { + "id": "expr1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "expr1: EcxOperand", + "range": { + "start": 140418, + "end": 140455 + }, + "inputs": [] + }, + { + "id": "expr2", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "expr2: EcxOperand", + "range": { + "start": 140460, + "end": 140497 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "lhs: EcxExpr", + "range": { + "start": 140502, + "end": 140534 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty: EcxType", + "range": { + "start": 140539, + "end": 140570 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "Ecxbmul", + "label": "_t1: Ecxbmul", + "range": { + "start": 140575, + "end": 140613 + }, + "inputs": [ + "ty", + "a", + "b" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxOperandAndCost", + "label": "_t2: EcxOperandAndCost", + "range": { + "start": 140618, + "end": 140661 + }, + "inputs": [ + "expr1" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxExtractedOperand", + "label": "_f3: EcxExtractedOperand", + "range": { + "start": 140666, + "end": 140707 + }, + "inputs": [ + "a" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxOperandAndCost", + "label": "_t4: EcxOperandAndCost", + "range": { + "start": 140712, + "end": 140755 + }, + "inputs": [ + "expr2" + ] + }, + { + "id": "_f5", + "kind": "query", + "dsl_type": "EcxExtractedOperand", + "label": "_f5: EcxExtractedOperand", + "range": { + "start": 140760, + "end": 140801 + }, + "inputs": [ + "b" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "a", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "b", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "expr1", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "a", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "expr2", + "kind": "operand", + "index": 0 + }, + { + "from": "_f5", + "to": "b", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "a", + "b", + "cost1", + "cost2", + "expr1", + "expr2", + "lhs", + "ty", + "_t1", + "_t2", + "_f3", + "_t4", + "_f5" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 141149, + "end": 141151 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "cost1.handle().eq(&_t2.handle_a1())", + "semantic_text": "cost1 == _t2.a1", + "referenced_vars": [ + "_t2", + "cost1" + ], + "range": { + "start": 141165, + "end": 141167 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "_t2.handle().eq(&_f3.handle())", + "semantic_text": "_t2 == _f3", + "referenced_vars": [ + "_f3", + "_t2" + ], + "range": { + "start": 141181, + "end": 141183 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "cost2.handle().eq(&_t4.handle_a1())", + "semantic_text": "cost2 == _t4.a1", + "referenced_vars": [ + "_t4", + "cost2" + ], + "range": { + "start": 141197, + "end": 141199 + } + }, + { + "id": "constraint_4", + "source_text": "c4", + "resolved_text": "_t4.handle().eq(&_f5.handle())", + "semantic_text": "_t4 == _f5", + "referenced_vars": [ + "_f5", + "_t4" + ], + "range": { + "start": 141213, + "end": 141215 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@238412:238460", + "bound_var": "t2", + "source_text": "ctx.insert_ecxbmul(pat.ty, pat.expr1, pat.expr2)", + "semantic_text": null, + "referenced_pat_vars": [ + "expr1", + "expr2", + "ty" + ], + "referenced_action_vars": [], + "range": { + "start": 238412, + "end": 238460 + } + }, + { + "id": "effect_1", + "effect_id": "effect@238479:238607", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_expr_and_cost(\n t2,\n (1_i64 + (ctx.devalue(pat.cost1) + ctx.devalue(pat.cost2))),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "cost1", + "cost2" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 238479, + "end": 238607 + } + }, + { + "id": "effect_2", + "effect_id": "effect@238617:238656", + "bound_var": null, + "source_text": "ctx.set_ecx_extracted_expr(pat.lhs, t1)", + "semantic_text": "ecx_extracted_expr(pat.lhs) = t1", + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 238617, + "end": 238656 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0160", + "premises": [ + { + "target_id": "cost1", + "label": "cost1: ", + "plain_source": "cost1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $]" + }, + { + "target_id": "cost2", + "label": "cost2: ", + "plain_source": "cost2", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]" + }, + { + "target_id": "_t1", + "label": "_t1: Ecxbmul", + "plain_source": "upright(\"bmul\")(upright(\"ty\"), a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxOperandAndCost", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxExtractedOperand", + "plain_source": "upright(\"EcxExtractedOperand\")(a)", + "colored_source": "upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxOperandAndCost", + "plain_source": "upright(\"_t4\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $]" + }, + { + "target_id": "_f5", + "label": "_f5: EcxExtractedOperand", + "plain_source": "upright(\"EcxExtractedOperand\")(b)", + "colored_source": "upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $])" + } + ], + "side_conditions": [ + "upright(\"lhs\") == upright(\"_t1\")", + "upright(\"cost1\") == upright(\"_t2.a1\")", + "upright(\"_t2\") == upright(\"_f3\")", + "upright(\"cost2\") == upright(\"_t4.a1\")", + "upright(\"_t4\") == upright(\"_f5\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_2", + "entry": { + "target_id": "effect:effect_2", + "label": "effect_2", + "plain_source": "upright(\"ecx_extracted_expr\")(upright(\"lhs\")) = upright(\"ExprAndCost\")((upright(\"bmul\")(upright(\"ty\"), expr1, expr2)), 1 + upright(\"cost1\") + upright(\"cost2\"))", + "colored_source": "upright(\"ecx_extracted_expr\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"ExprAndCost\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ expr1 $], #text(fill: rgb(\"#5F7A8A\"))[$ expr2 $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ 1 + upright(\"cost1\") + upright(\"cost2\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(cost1 \\ cost2 \\ upright(\"bmul\")(upright(\"ty\"), a, b) \\ upright(\"_t2\") \\ upright(\"EcxExtractedOperand\")(a) \\ upright(\"_t4\") \\ upright(\"EcxExtractedOperand\")(b), upright(\"ecx_extracted_expr\")(upright(\"lhs\")) = upright(\"ExprAndCost\")((upright(\"bmul\")(upright(\"ty\"), expr1, expr2)), 1 + upright(\"cost1\") + upright(\"cost2\"))) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\") \\ upright(\"cost2\") == upright(\"_t4.a1\") \\ upright(\"_t4\") == upright(\"_f5\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $] \\ upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $]), upright(\"ecx_extracted_expr\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"ExprAndCost\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ expr1 $], #text(fill: rgb(\"#5F7A8A\"))[$ expr2 $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ 1 + upright(\"cost1\") + upright(\"cost2\") $]) $]) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\") \\ upright(\"cost2\") == upright(\"_t4.a1\") \\ upright(\"_t4\") == upright(\"_f5\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7552_5_MyTxEggccExtraction_add_rule__r0161__7d3fa9c51d89bac0", + "display_name": "r0161", + "rule_name": "r0161", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 238670, + "line": 7552, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 238670, + "end": 239010 + }, + "pattern_range": { + "start": 238715, + "end": 238726 + }, + "action_range": { + "start": 238728, + "end": 239009 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 141605, + "end": 141638 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 141643, + "end": 141676 + }, + "inputs": [] + }, + { + "id": "cost1", + "kind": "query", + "dsl_type": "", + "label": "cost1: ", + "range": { + "start": 141681, + "end": 141734 + }, + "inputs": [] + }, + { + "id": "cost2", + "kind": "query", + "dsl_type": "", + "label": "cost2: ", + "range": { + "start": 141739, + "end": 141792 + }, + "inputs": [] + }, + { + "id": "expr1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "expr1: EcxOperand", + "range": { + "start": 141797, + "end": 141834 + }, + "inputs": [] + }, + { + "id": "expr2", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "expr2: EcxOperand", + "range": { + "start": 141839, + "end": 141876 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "lhs: EcxExpr", + "range": { + "start": 141881, + "end": 141913 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty: EcxType", + "range": { + "start": 141918, + "end": 141949 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "Ecxbdiv", + "label": "_t1: Ecxbdiv", + "range": { + "start": 141954, + "end": 141992 + }, + "inputs": [ + "ty", + "a", + "b" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxOperandAndCost", + "label": "_t2: EcxOperandAndCost", + "range": { + "start": 141997, + "end": 142040 + }, + "inputs": [ + "expr1" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxExtractedOperand", + "label": "_f3: EcxExtractedOperand", + "range": { + "start": 142045, + "end": 142086 + }, + "inputs": [ + "a" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxOperandAndCost", + "label": "_t4: EcxOperandAndCost", + "range": { + "start": 142091, + "end": 142134 + }, + "inputs": [ + "expr2" + ] + }, + { + "id": "_f5", + "kind": "query", + "dsl_type": "EcxExtractedOperand", + "label": "_f5: EcxExtractedOperand", + "range": { + "start": 142139, + "end": 142180 + }, + "inputs": [ + "b" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "a", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "b", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "expr1", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "a", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "expr2", + "kind": "operand", + "index": 0 + }, + { + "from": "_f5", + "to": "b", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "a", + "b", + "cost1", + "cost2", + "expr1", + "expr2", + "lhs", + "ty", + "_t1", + "_t2", + "_f3", + "_t4", + "_f5" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 142528, + "end": 142530 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "cost1.handle().eq(&_t2.handle_a1())", + "semantic_text": "cost1 == _t2.a1", + "referenced_vars": [ + "_t2", + "cost1" + ], + "range": { + "start": 142544, + "end": 142546 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "_t2.handle().eq(&_f3.handle())", + "semantic_text": "_t2 == _f3", + "referenced_vars": [ + "_f3", + "_t2" + ], + "range": { + "start": 142560, + "end": 142562 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "cost2.handle().eq(&_t4.handle_a1())", + "semantic_text": "cost2 == _t4.a1", + "referenced_vars": [ + "_t4", + "cost2" + ], + "range": { + "start": 142576, + "end": 142578 + } + }, + { + "id": "constraint_4", + "source_text": "c4", + "resolved_text": "_t4.handle().eq(&_f5.handle())", + "semantic_text": "_t4 == _f5", + "referenced_vars": [ + "_f5", + "_t4" + ], + "range": { + "start": 142592, + "end": 142594 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@238758:238806", + "bound_var": "t2", + "source_text": "ctx.insert_ecxbdiv(pat.ty, pat.expr1, pat.expr2)", + "semantic_text": null, + "referenced_pat_vars": [ + "expr1", + "expr2", + "ty" + ], + "referenced_action_vars": [], + "range": { + "start": 238758, + "end": 238806 + } + }, + { + "id": "effect_1", + "effect_id": "effect@238825:238953", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_expr_and_cost(\n t2,\n (1_i64 + (ctx.devalue(pat.cost1) + ctx.devalue(pat.cost2))),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "cost1", + "cost2" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 238825, + "end": 238953 + } + }, + { + "id": "effect_2", + "effect_id": "effect@238963:239002", + "bound_var": null, + "source_text": "ctx.set_ecx_extracted_expr(pat.lhs, t1)", + "semantic_text": "ecx_extracted_expr(pat.lhs) = t1", + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 238963, + "end": 239002 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0161", + "premises": [ + { + "target_id": "cost1", + "label": "cost1: ", + "plain_source": "cost1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $]" + }, + { + "target_id": "cost2", + "label": "cost2: ", + "plain_source": "cost2", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]" + }, + { + "target_id": "_t1", + "label": "_t1: Ecxbdiv", + "plain_source": "upright(\"bdiv\")(upright(\"ty\"), a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxOperandAndCost", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxExtractedOperand", + "plain_source": "upright(\"EcxExtractedOperand\")(a)", + "colored_source": "upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxOperandAndCost", + "plain_source": "upright(\"_t4\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $]" + }, + { + "target_id": "_f5", + "label": "_f5: EcxExtractedOperand", + "plain_source": "upright(\"EcxExtractedOperand\")(b)", + "colored_source": "upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $])" + } + ], + "side_conditions": [ + "upright(\"lhs\") == upright(\"_t1\")", + "upright(\"cost1\") == upright(\"_t2.a1\")", + "upright(\"_t2\") == upright(\"_f3\")", + "upright(\"cost2\") == upright(\"_t4.a1\")", + "upright(\"_t4\") == upright(\"_f5\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_2", + "entry": { + "target_id": "effect:effect_2", + "label": "effect_2", + "plain_source": "upright(\"ecx_extracted_expr\")(upright(\"lhs\")) = upright(\"ExprAndCost\")((upright(\"bdiv\")(upright(\"ty\"), expr1, expr2)), 1 + upright(\"cost1\") + upright(\"cost2\"))", + "colored_source": "upright(\"ecx_extracted_expr\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"ExprAndCost\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ expr1 $], #text(fill: rgb(\"#5F7A8A\"))[$ expr2 $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ 1 + upright(\"cost1\") + upright(\"cost2\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(cost1 \\ cost2 \\ upright(\"bdiv\")(upright(\"ty\"), a, b) \\ upright(\"_t2\") \\ upright(\"EcxExtractedOperand\")(a) \\ upright(\"_t4\") \\ upright(\"EcxExtractedOperand\")(b), upright(\"ecx_extracted_expr\")(upright(\"lhs\")) = upright(\"ExprAndCost\")((upright(\"bdiv\")(upright(\"ty\"), expr1, expr2)), 1 + upright(\"cost1\") + upright(\"cost2\"))) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\") \\ upright(\"cost2\") == upright(\"_t4.a1\") \\ upright(\"_t4\") == upright(\"_f5\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $] \\ upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $]), upright(\"ecx_extracted_expr\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"ExprAndCost\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bdiv\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ expr1 $], #text(fill: rgb(\"#5F7A8A\"))[$ expr2 $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ 1 + upright(\"cost1\") + upright(\"cost2\") $]) $]) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\") \\ upright(\"cost2\") == upright(\"_t4.a1\") \\ upright(\"_t4\") == upright(\"_f5\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7560_5_MyTxEggccExtraction_add_rule__r0162__25159bcb7c33a4b0", + "display_name": "r0162", + "rule_name": "r0162", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 239016, + "line": 7560, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 239016, + "end": 239355 + }, + "pattern_range": { + "start": 239061, + "end": 239072 + }, + "action_range": { + "start": 239074, + "end": 239354 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 142983, + "end": 143016 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 143021, + "end": 143054 + }, + "inputs": [] + }, + { + "id": "cost1", + "kind": "query", + "dsl_type": "", + "label": "cost1: ", + "range": { + "start": 143059, + "end": 143112 + }, + "inputs": [] + }, + { + "id": "cost2", + "kind": "query", + "dsl_type": "", + "label": "cost2: ", + "range": { + "start": 143117, + "end": 143170 + }, + "inputs": [] + }, + { + "id": "expr1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "expr1: EcxOperand", + "range": { + "start": 143175, + "end": 143212 + }, + "inputs": [] + }, + { + "id": "expr2", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "expr2: EcxOperand", + "range": { + "start": 143217, + "end": 143254 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "lhs: EcxExpr", + "range": { + "start": 143259, + "end": 143291 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty: EcxType", + "range": { + "start": 143296, + "end": 143327 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "Ecxblt", + "label": "_t1: Ecxblt", + "range": { + "start": 143332, + "end": 143369 + }, + "inputs": [ + "ty", + "a", + "b" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxOperandAndCost", + "label": "_t2: EcxOperandAndCost", + "range": { + "start": 143374, + "end": 143417 + }, + "inputs": [ + "expr1" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxExtractedOperand", + "label": "_f3: EcxExtractedOperand", + "range": { + "start": 143422, + "end": 143463 + }, + "inputs": [ + "a" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxOperandAndCost", + "label": "_t4: EcxOperandAndCost", + "range": { + "start": 143468, + "end": 143511 + }, + "inputs": [ + "expr2" + ] + }, + { + "id": "_f5", + "kind": "query", + "dsl_type": "EcxExtractedOperand", + "label": "_f5: EcxExtractedOperand", + "range": { + "start": 143516, + "end": 143557 + }, + "inputs": [ + "b" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "a", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "b", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "expr1", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "a", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "expr2", + "kind": "operand", + "index": 0 + }, + { + "from": "_f5", + "to": "b", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "a", + "b", + "cost1", + "cost2", + "expr1", + "expr2", + "lhs", + "ty", + "_t1", + "_t2", + "_f3", + "_t4", + "_f5" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 143905, + "end": 143907 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "cost1.handle().eq(&_t2.handle_a1())", + "semantic_text": "cost1 == _t2.a1", + "referenced_vars": [ + "_t2", + "cost1" + ], + "range": { + "start": 143921, + "end": 143923 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "_t2.handle().eq(&_f3.handle())", + "semantic_text": "_t2 == _f3", + "referenced_vars": [ + "_f3", + "_t2" + ], + "range": { + "start": 143937, + "end": 143939 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "cost2.handle().eq(&_t4.handle_a1())", + "semantic_text": "cost2 == _t4.a1", + "referenced_vars": [ + "_t4", + "cost2" + ], + "range": { + "start": 143953, + "end": 143955 + } + }, + { + "id": "constraint_4", + "source_text": "c4", + "resolved_text": "_t4.handle().eq(&_f5.handle())", + "semantic_text": "_t4 == _f5", + "referenced_vars": [ + "_f5", + "_t4" + ], + "range": { + "start": 143969, + "end": 143971 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@239104:239151", + "bound_var": "t2", + "source_text": "ctx.insert_ecxblt(pat.ty, pat.expr1, pat.expr2)", + "semantic_text": null, + "referenced_pat_vars": [ + "expr1", + "expr2", + "ty" + ], + "referenced_action_vars": [], + "range": { + "start": 239104, + "end": 239151 + } + }, + { + "id": "effect_1", + "effect_id": "effect@239170:239298", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_expr_and_cost(\n t2,\n (1_i64 + (ctx.devalue(pat.cost1) + ctx.devalue(pat.cost2))),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "cost1", + "cost2" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 239170, + "end": 239298 + } + }, + { + "id": "effect_2", + "effect_id": "effect@239308:239347", + "bound_var": null, + "source_text": "ctx.set_ecx_extracted_expr(pat.lhs, t1)", + "semantic_text": "ecx_extracted_expr(pat.lhs) = t1", + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 239308, + "end": 239347 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0162", + "premises": [ + { + "target_id": "cost1", + "label": "cost1: ", + "plain_source": "cost1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $]" + }, + { + "target_id": "cost2", + "label": "cost2: ", + "plain_source": "cost2", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]" + }, + { + "target_id": "_t1", + "label": "_t1: Ecxblt", + "plain_source": "upright(\"blt\")(upright(\"ty\"), a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxOperandAndCost", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxExtractedOperand", + "plain_source": "upright(\"EcxExtractedOperand\")(a)", + "colored_source": "upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxOperandAndCost", + "plain_source": "upright(\"_t4\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $]" + }, + { + "target_id": "_f5", + "label": "_f5: EcxExtractedOperand", + "plain_source": "upright(\"EcxExtractedOperand\")(b)", + "colored_source": "upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $])" + } + ], + "side_conditions": [ + "upright(\"lhs\") == upright(\"_t1\")", + "upright(\"cost1\") == upright(\"_t2.a1\")", + "upright(\"_t2\") == upright(\"_f3\")", + "upright(\"cost2\") == upright(\"_t4.a1\")", + "upright(\"_t4\") == upright(\"_f5\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_2", + "entry": { + "target_id": "effect:effect_2", + "label": "effect_2", + "plain_source": "upright(\"ecx_extracted_expr\")(upright(\"lhs\")) = upright(\"ExprAndCost\")((upright(\"blt\")(upright(\"ty\"), expr1, expr2)), 1 + upright(\"cost1\") + upright(\"cost2\"))", + "colored_source": "upright(\"ecx_extracted_expr\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"ExprAndCost\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ expr1 $], #text(fill: rgb(\"#5F7A8A\"))[$ expr2 $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ 1 + upright(\"cost1\") + upright(\"cost2\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(cost1 \\ cost2 \\ upright(\"blt\")(upright(\"ty\"), a, b) \\ upright(\"_t2\") \\ upright(\"EcxExtractedOperand\")(a) \\ upright(\"_t4\") \\ upright(\"EcxExtractedOperand\")(b), upright(\"ecx_extracted_expr\")(upright(\"lhs\")) = upright(\"ExprAndCost\")((upright(\"blt\")(upright(\"ty\"), expr1, expr2)), 1 + upright(\"cost1\") + upright(\"cost2\"))) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\") \\ upright(\"cost2\") == upright(\"_t4.a1\") \\ upright(\"_t4\") == upright(\"_f5\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $] \\ upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $]), upright(\"ecx_extracted_expr\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"ExprAndCost\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ expr1 $], #text(fill: rgb(\"#5F7A8A\"))[$ expr2 $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ 1 + upright(\"cost1\") + upright(\"cost2\") $]) $]) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\") \\ upright(\"cost2\") == upright(\"_t4.a1\") \\ upright(\"_t4\") == upright(\"_f5\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7568_5_MyTxEggccExtraction_add_rule__r0163__3969953167f9533b", + "display_name": "r0163", + "rule_name": "r0163", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 239361, + "line": 7568, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 239361, + "end": 239695 + }, + "pattern_range": { + "start": 239406, + "end": 239417 + }, + "action_range": { + "start": 239419, + "end": 239694 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 144345, + "end": 144378 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 144383, + "end": 144416 + }, + "inputs": [] + }, + { + "id": "cost1", + "kind": "query", + "dsl_type": "", + "label": "cost1: ", + "range": { + "start": 144421, + "end": 144474 + }, + "inputs": [] + }, + { + "id": "cost2", + "kind": "query", + "dsl_type": "", + "label": "cost2: ", + "range": { + "start": 144479, + "end": 144532 + }, + "inputs": [] + }, + { + "id": "expr1", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "expr1: EcxOperand", + "range": { + "start": 144537, + "end": 144574 + }, + "inputs": [] + }, + { + "id": "expr2", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "expr2: EcxOperand", + "range": { + "start": 144579, + "end": 144616 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "lhs: EcxExpr", + "range": { + "start": 144621, + "end": 144653 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxPRINT", + "label": "_t1: EcxPRINT", + "range": { + "start": 144658, + "end": 144692 + }, + "inputs": [ + "a", + "b" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxOperandAndCost", + "label": "_t2: EcxOperandAndCost", + "range": { + "start": 144697, + "end": 144740 + }, + "inputs": [ + "expr1" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxExtractedOperand", + "label": "_f3: EcxExtractedOperand", + "range": { + "start": 144745, + "end": 144786 + }, + "inputs": [ + "a" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxOperandAndCost", + "label": "_t4: EcxOperandAndCost", + "range": { + "start": 144791, + "end": 144834 + }, + "inputs": [ + "expr2" + ] + }, + { + "id": "_f5", + "kind": "query", + "dsl_type": "EcxExtractedOperand", + "label": "_f5: EcxExtractedOperand", + "range": { + "start": 144839, + "end": 144880 + }, + "inputs": [ + "b" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "a", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "b", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "expr1", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "a", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "expr2", + "kind": "operand", + "index": 0 + }, + { + "from": "_f5", + "to": "b", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "a", + "b", + "cost1", + "cost2", + "expr1", + "expr2", + "lhs", + "_t1", + "_t2", + "_f3", + "_t4", + "_f5" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 145224, + "end": 145226 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "cost1.handle().eq(&_t2.handle_a1())", + "semantic_text": "cost1 == _t2.a1", + "referenced_vars": [ + "_t2", + "cost1" + ], + "range": { + "start": 145240, + "end": 145242 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "_t2.handle().eq(&_f3.handle())", + "semantic_text": "_t2 == _f3", + "referenced_vars": [ + "_f3", + "_t2" + ], + "range": { + "start": 145256, + "end": 145258 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "cost2.handle().eq(&_t4.handle_a1())", + "semantic_text": "cost2 == _t4.a1", + "referenced_vars": [ + "_t4", + "cost2" + ], + "range": { + "start": 145272, + "end": 145274 + } + }, + { + "id": "constraint_4", + "source_text": "c4", + "resolved_text": "_t4.handle().eq(&_f5.handle())", + "semantic_text": "_t4 == _f5", + "referenced_vars": [ + "_f5", + "_t4" + ], + "range": { + "start": 145288, + "end": 145290 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@239449:239491", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_print(pat.expr1, pat.expr2)", + "semantic_text": null, + "referenced_pat_vars": [ + "expr1", + "expr2" + ], + "referenced_action_vars": [], + "range": { + "start": 239449, + "end": 239491 + } + }, + { + "id": "effect_1", + "effect_id": "effect@239510:239638", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_expr_and_cost(\n t2,\n (1_i64 + (ctx.devalue(pat.cost1) + ctx.devalue(pat.cost2))),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "cost1", + "cost2" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 239510, + "end": 239638 + } + }, + { + "id": "effect_2", + "effect_id": "effect@239648:239687", + "bound_var": null, + "source_text": "ctx.set_ecx_extracted_expr(pat.lhs, t1)", + "semantic_text": "ecx_extracted_expr(pat.lhs) = t1", + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 239648, + "end": 239687 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0163", + "premises": [ + { + "target_id": "cost1", + "label": "cost1: ", + "plain_source": "cost1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $]" + }, + { + "target_id": "cost2", + "label": "cost2: ", + "plain_source": "cost2", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ cost2 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxPRINT", + "plain_source": "upright(\"PRINT\")(a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PRINT\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxOperandAndCost", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxExtractedOperand", + "plain_source": "upright(\"EcxExtractedOperand\")(a)", + "colored_source": "upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxOperandAndCost", + "plain_source": "upright(\"_t4\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $]" + }, + { + "target_id": "_f5", + "label": "_f5: EcxExtractedOperand", + "plain_source": "upright(\"EcxExtractedOperand\")(b)", + "colored_source": "upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $])" + } + ], + "side_conditions": [ + "upright(\"lhs\") == upright(\"_t1\")", + "upright(\"cost1\") == upright(\"_t2.a1\")", + "upright(\"_t2\") == upright(\"_f3\")", + "upright(\"cost2\") == upright(\"_t4.a1\")", + "upright(\"_t4\") == upright(\"_f5\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_2", + "entry": { + "target_id": "effect:effect_2", + "label": "effect_2", + "plain_source": "upright(\"ecx_extracted_expr\")(upright(\"lhs\")) = upright(\"ExprAndCost\")(upright(\"EcxPrint\")(expr1, expr2), 1 + upright(\"cost1\") + upright(\"cost2\"))", + "colored_source": "upright(\"ecx_extracted_expr\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"ExprAndCost\")(upright(\"EcxPrint\")(#text(fill: rgb(\"#5F7A8A\"))[$ expr1 $], #text(fill: rgb(\"#5F7A8A\"))[$ expr2 $]), #text(fill: rgb(\"#B86A5B\"))[$ 1 + upright(\"cost1\") + upright(\"cost2\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(cost1 \\ cost2 \\ upright(\"PRINT\")(a, b) \\ upright(\"_t2\") \\ upright(\"EcxExtractedOperand\")(a) \\ upright(\"_t4\") \\ upright(\"EcxExtractedOperand\")(b), upright(\"ecx_extracted_expr\")(upright(\"lhs\")) = upright(\"ExprAndCost\")(upright(\"EcxPrint\")(expr1, expr2), 1 + upright(\"cost1\") + upright(\"cost2\"))) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\") \\ upright(\"cost2\") == upright(\"_t4.a1\") \\ upright(\"_t4\") == upright(\"_f5\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ cost1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ cost2 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PRINT\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $] \\ upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $]), upright(\"ecx_extracted_expr\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"ExprAndCost\")(upright(\"EcxPrint\")(#text(fill: rgb(\"#5F7A8A\"))[$ expr1 $], #text(fill: rgb(\"#5F7A8A\"))[$ expr2 $]), #text(fill: rgb(\"#B86A5B\"))[$ 1 + upright(\"cost1\") + upright(\"cost2\") $]) $]) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\") \\ upright(\"cost1\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\") \\ upright(\"cost2\") == upright(\"_t4.a1\") \\ upright(\"_t4\") == upright(\"_f5\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7576_5_MyTxEggccExtraction_add_rule__r0164__f764b5b2c54f66e5", + "display_name": "r0164", + "rule_name": "r0164", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 239701, + "line": 7576, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 239701, + "end": 240160 + }, + "pattern_range": { + "start": 239746, + "end": 239757 + }, + "action_range": { + "start": 239759, + "end": 240159 + } + }, + "nodes": [ + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "vec: EcxVecOperandBase", + "range": { + "start": 145449, + "end": 145491 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t1: EcxVO", + "range": { + "start": 145496, + "end": 145525 + }, + "inputs": [ + "vec" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "vec", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "vec", + "_t1" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@239789:239815", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_vo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 239789, + "end": 239815 + } + }, + { + "id": "effect_1", + "effect_id": "effect@239834:240022", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_vo(\n ctx.intern_container::>(VecContainer::<\n EcxOperand,\n >::new(\n )),\n )", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 239834, + "end": 240022 + } + }, + { + "id": "effect_2", + "effect_id": "effect@240041:240087", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_vec_operand_and_cost(t3, 0_i64)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t3" + ], + "range": { + "start": 240041, + "end": 240087 + } + }, + { + "id": "effect_3", + "effect_id": "effect@240097:240152", + "bound_var": null, + "source_text": "ctx.set_ecx_extracted_vec_operand_helper(t1, 0_i64, t2)", + "semantic_text": "ecx_extracted_vec_operand_helper(t1, 0) = t2", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t1", + "t2" + ], + "range": { + "start": 240097, + "end": 240152 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0164", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_3", + "entry": { + "target_id": "effect:effect_3", + "label": "effect_3", + "plain_source": "upright(\"ecx_extracted_vec_operand_helper\")(upright(\"EcxVo\")(upright(\"vec\")), 0) = upright(\"VecOperandAndCost\")(upright(\"EcxVo\")(upright(\"intern_container\")::>(upright(\"VecContainer\")::< upright(\"EcxOperand\"), >::upright(\"new\")())), 0)", + "colored_source": "upright(\"ecx_extracted_vec_operand_helper\")(upright(\"EcxVo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 0 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"VecOperandAndCost\")(upright(\"EcxVo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"VecContainer\")::< upright(\"EcxOperand\"), >::upright(\"new\")()) $]), #text(fill: rgb(\"#B86A5B\"))[$ 0 $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"VO\")(upright(\"vec\")), upright(\"ecx_extracted_vec_operand_helper\")(upright(\"EcxVo\")(upright(\"vec\")), 0) = upright(\"VecOperandAndCost\")(upright(\"EcxVo\")(upright(\"intern_container\")::>(upright(\"VecContainer\")::< upright(\"EcxOperand\"), >::upright(\"new\")())), 0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], upright(\"ecx_extracted_vec_operand_helper\")(upright(\"EcxVo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 0 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"VecOperandAndCost\")(upright(\"EcxVo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"VecContainer\")::< upright(\"EcxOperand\"), >::upright(\"new\")()) $]), #text(fill: rgb(\"#B86A5B\"))[$ 0 $]) $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7587_5_MyTxEggccExtraction_add_rule__r0165__4163a636bec615da", + "display_name": "r0165", + "rule_name": "r0165", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 240166, + "line": 7587, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 240166, + "end": 240811 + }, + "pattern_range": { + "start": 240211, + "end": 240222 + }, + "action_range": { + "start": 240224, + "end": 240810 + } + }, + "nodes": [ + { + "id": "current", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "current: EcxVecOperandBase", + "range": { + "start": 146023, + "end": 146069 + }, + "inputs": [] + }, + { + "id": "current_cost", + "kind": "query", + "dsl_type": "", + "label": "current_cost: ", + "range": { + "start": 146074, + "end": 146141 + }, + "inputs": [] + }, + { + "id": "expr", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "expr: EcxOperand", + "range": { + "start": 146146, + "end": 146182 + }, + "inputs": [] + }, + { + "id": "expr_cost", + "kind": "query", + "dsl_type": "", + "label": "expr_cost: ", + "range": { + "start": 146187, + "end": 146248 + }, + "inputs": [] + }, + { + "id": "index", + "kind": "query", + "dsl_type": "", + "label": "index: ", + "range": { + "start": 146253, + "end": 146306 + }, + "inputs": [] + }, + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "vec: EcxVecOperandBase", + "range": { + "start": 146311, + "end": 146353 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t2: EcxVO", + "range": { + "start": 146358, + "end": 146391 + }, + "inputs": [ + "current" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxVecOperandAndCost", + "label": "_t1: EcxVecOperandAndCost", + "range": { + "start": 146396, + "end": 146440 + }, + "inputs": [ + "_t2" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t4: EcxVO", + "range": { + "start": 146445, + "end": 146474 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxExtractedVecOperandHelper", + "label": "_f3: EcxExtractedVecOperandHelper", + "range": { + "start": 146479, + "end": 146539 + }, + "inputs": [ + "_t4", + "index" + ] + }, + { + "id": "_t6", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t6: EcxVO", + "range": { + "start": 146544, + "end": 146573 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_f5", + "kind": "query", + "dsl_type": "EcxVecOperand_length", + "label": "_f5: EcxVecOperand_length", + "range": { + "start": 146578, + "end": 146622 + }, + "inputs": [ + "_t6" + ] + }, + { + "id": "_t9", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t9: EcxVO", + "range": { + "start": 146627, + "end": 146656 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_t8", + "kind": "query", + "dsl_type": "EcxVecOperand_get", + "label": "_t8: EcxVecOperand_get", + "range": { + "start": 146661, + "end": 146702 + }, + "inputs": [ + "_t9" + ] + }, + { + "id": "_f7", + "kind": "query", + "dsl_type": "EcxExtractedOperand", + "label": "_f7: EcxExtractedOperand", + "range": { + "start": 146707, + "end": 146750 + }, + "inputs": [ + "_t8" + ] + }, + { + "id": "_t10", + "kind": "query", + "dsl_type": "EcxOperandAndCost", + "label": "_t10: EcxOperandAndCost", + "range": { + "start": 146755, + "end": 146798 + }, + "inputs": [ + "expr" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "current", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "_t4", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "index", + "kind": "operand", + "index": 1 + }, + { + "from": "_t6", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_f5", + "to": "_t6", + "kind": "operand", + "index": 0 + }, + { + "from": "_t9", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_t8", + "to": "_t9", + "kind": "operand", + "index": 0 + }, + { + "from": "_f7", + "to": "_t8", + "kind": "operand", + "index": 0 + }, + { + "from": "_t10", + "to": "expr", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "current", + "current_cost", + "expr", + "expr_cost", + "index", + "vec", + "_t1", + "_t2", + "_f3", + "_t4", + "_f5", + "_t6", + "_f7", + "_t8", + "_t9", + "_t10" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "current_cost.handle().eq(&_t1.handle_a1())", + "semantic_text": "current_cost == _t1.a1", + "referenced_vars": [ + "_t1", + "current_cost" + ], + "range": { + "start": 147366, + "end": 147368 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "_t1.handle().eq(&_f3.handle())", + "semantic_text": "_t1 == _f3", + "referenced_vars": [ + "_f3", + "_t1" + ], + "range": { + "start": 147382, + "end": 147384 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "index.handle().lt(&_f5.handle())", + "semantic_text": "index < _f5", + "referenced_vars": [ + "_f5", + "index" + ], + "range": { + "start": 147398, + "end": 147400 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "index.handle().eq(&_t8.handle_a1())", + "semantic_text": "index == _t8.a1", + "referenced_vars": [ + "_t8", + "index" + ], + "range": { + "start": 147414, + "end": 147416 + } + }, + { + "id": "constraint_4", + "source_text": "c4", + "resolved_text": "expr_cost.handle().eq(&_t10.handle_a1())", + "semantic_text": "expr_cost == _t10.a1", + "referenced_vars": [ + "_t10", + "expr_cost" + ], + "range": { + "start": 147430, + "end": 147432 + } + }, + { + "id": "constraint_5", + "source_text": "c5", + "resolved_text": "_f7.handle().eq(&_t10.handle())", + "semantic_text": "_f7 == _t10", + "referenced_vars": [ + "_f7", + "_t10" + ], + "range": { + "start": 147446, + "end": 147448 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@240254:240280", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_vo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 240254, + "end": 240280 + } + }, + { + "id": "effect_1", + "effect_id": "effect@240299:240556", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_vo(\n ctx.intern_container::>(vec_push::<\n EcxOperand,\n >(\n &*ctx.devalue(pat.current),\n pat.expr.erase(),\n )),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "current", + "expr" + ], + "referenced_action_vars": [], + "range": { + "start": 240299, + "end": 240556 + } + }, + { + "id": "effect_2", + "effect_id": "effect@240575:240711", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_vec_operand_and_cost(\n t3,\n (ctx.devalue(pat.current_cost) + ctx.devalue(pat.expr_cost)),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "current_cost", + "expr_cost" + ], + "referenced_action_vars": [ + "t3" + ], + "range": { + "start": 240575, + "end": 240711 + } + }, + { + "id": "effect_3", + "effect_id": "effect@240721:240803", + "bound_var": null, + "source_text": "ctx.set_ecx_extracted_vec_operand_helper(t1, (ctx.devalue(pat.index) + 1_i64), t2)", + "semantic_text": "ecx_extracted_vec_operand_helper(t1, ctx.devalue(pat.index) + 1) = t2", + "referenced_pat_vars": [ + "index" + ], + "referenced_action_vars": [ + "t1", + "t2" + ], + "range": { + "start": 240721, + "end": 240803 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0165", + "premises": [ + { + "target_id": "current_cost", + "label": "current_cost: ", + "plain_source": "upright(\"current_cost\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"current_cost\") $]" + }, + { + "target_id": "expr_cost", + "label": "expr_cost: ", + "plain_source": "upright(\"expr_cost\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr_cost\") $]" + }, + { + "target_id": "index", + "label": "index: ", + "plain_source": "upright(\"index\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxVecOperandAndCost", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"current\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"current\") $]) $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxExtractedVecOperandHelper", + "plain_source": "upright(\"EcxExtractedVecOperandHelper\")(upright(\"VO\")(upright(\"vec\")), upright(\"index\"))", + "colored_source": "upright(\"EcxExtractedVecOperandHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + }, + { + "target_id": "_f5", + "label": "_f5: EcxVecOperand_length", + "plain_source": "upright(\"EcxVecOperand_length\")(upright(\"VO\")(upright(\"vec\")))", + "colored_source": "upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $])" + }, + { + "target_id": "_t6", + "label": "_t6: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + }, + { + "target_id": "_f7", + "label": "_f7: EcxExtractedOperand", + "plain_source": "upright(\"EcxExtractedOperand\")(upright(\"_t8\"))", + "colored_source": "upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t8\") $])" + }, + { + "target_id": "_t8", + "label": "_t8: EcxVecOperand_get", + "plain_source": "upright(\"_t8\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t8\") $]" + }, + { + "target_id": "_t9", + "label": "_t9: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + }, + { + "target_id": "_t10", + "label": "_t10: EcxOperandAndCost", + "plain_source": "upright(\"_t10\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $]" + } + ], + "side_conditions": [ + "upright(\"current_cost\") == upright(\"_t1.a1\")", + "upright(\"_t1\") == upright(\"_f3\")", + "upright(\"index\") < upright(\"_f5\")", + "upright(\"index\") == upright(\"_t8.a1\")", + "upright(\"expr_cost\") == upright(\"_t10.a1\")", + "upright(\"_f7\") == upright(\"_t10\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_3", + "entry": { + "target_id": "effect:effect_3", + "label": "effect_3", + "plain_source": "upright(\"ecx_extracted_vec_operand_helper\")(upright(\"EcxVo\")(upright(\"vec\")), upright(\"index\") + 1) = upright(\"VecOperandAndCost\")(upright(\"EcxVo\")(upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"current\"), upright(\"expr.erase\")()))), upright(\"current_cost\") + upright(\"expr_cost\"))", + "colored_source": "upright(\"ecx_extracted_vec_operand_helper\")(upright(\"EcxVo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]), #text(fill: rgb(\"#B86A5B\"))[$ upright(\"index\") + 1 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"VecOperandAndCost\")(upright(\"EcxVo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"current\"), upright(\"expr.erase\")())) $]), #text(fill: rgb(\"#B86A5B\"))[$ upright(\"current_cost\") + upright(\"expr_cost\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"current_cost\") \\ upright(\"expr_cost\") \\ upright(\"index\") \\ upright(\"_t1\") \\ upright(\"VO\")(upright(\"current\")) \\ upright(\"EcxExtractedVecOperandHelper\")(upright(\"VO\")(upright(\"vec\")), upright(\"index\")) \\ upright(\"VO\")(upright(\"vec\")) \\ upright(\"EcxVecOperand_length\")(upright(\"VO\")(upright(\"vec\"))) \\ upright(\"VO\")(upright(\"vec\")) \\ upright(\"EcxExtractedOperand\")(upright(\"_t8\")) \\ upright(\"_t8\") \\ upright(\"VO\")(upright(\"vec\")) \\ upright(\"_t10\"), upright(\"ecx_extracted_vec_operand_helper\")(upright(\"EcxVo\")(upright(\"vec\")), upright(\"index\") + 1) = upright(\"VecOperandAndCost\")(upright(\"EcxVo\")(upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"current\"), upright(\"expr.erase\")()))), upright(\"current_cost\") + upright(\"expr_cost\"))) quad upright(\"if\") quad upright(\"current_cost\") == upright(\"_t1.a1\") \\ upright(\"_t1\") == upright(\"_f3\") \\ upright(\"index\") < upright(\"_f5\") \\ upright(\"index\") == upright(\"_t8.a1\") \\ upright(\"expr_cost\") == upright(\"_t10.a1\") \\ upright(\"_f7\") == upright(\"_t10\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"current_cost\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr_cost\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"current\") $]) $] \\ upright(\"EcxExtractedVecOperandHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $] \\ upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $] \\ upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t8\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t8\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], upright(\"ecx_extracted_vec_operand_helper\")(upright(\"EcxVo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]), #text(fill: rgb(\"#B86A5B\"))[$ upright(\"index\") + 1 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"VecOperandAndCost\")(upright(\"EcxVo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"current\"), upright(\"expr.erase\")())) $]), #text(fill: rgb(\"#B86A5B\"))[$ upright(\"current_cost\") + upright(\"expr_cost\") $]) $]) quad upright(\"if\") quad upright(\"current_cost\") == upright(\"_t1.a1\") \\ upright(\"_t1\") == upright(\"_f3\") \\ upright(\"index\") < upright(\"_f5\") \\ upright(\"index\") == upright(\"_t8.a1\") \\ upright(\"expr_cost\") == upright(\"_t10.a1\") \\ upright(\"_f7\") == upright(\"_t10\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7603_5_MyTxEggccExtraction_add_rule__r0166__74ec3a0d3b69ec36", + "display_name": "r0166", + "rule_name": "r0166", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 240817, + "line": 7603, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 240817, + "end": 240998 + }, + "pattern_range": { + "start": 240862, + "end": 240873 + }, + "action_range": { + "start": 240875, + "end": 240997 + } + }, + "nodes": [ + { + "id": "index", + "kind": "query", + "dsl_type": "", + "label": "index: ", + "range": { + "start": 147706, + "end": 147759 + }, + "inputs": [] + }, + { + "id": "result", + "kind": "query_leaf", + "dsl_type": "EcxTermAndCost", + "label": "result: EcxTermAndCost", + "range": { + "start": 147764, + "end": 147806 + }, + "inputs": [] + }, + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "vec: EcxVecOperandBase", + "range": { + "start": 147811, + "end": 147853 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t2: EcxVO", + "range": { + "start": 147858, + "end": 147887 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_f1", + "kind": "query", + "dsl_type": "EcxExtractedVecOperandHelper", + "label": "_f1: EcxExtractedVecOperandHelper", + "range": { + "start": 147892, + "end": 147952 + }, + "inputs": [ + "_t2", + "index" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t4: EcxVO", + "range": { + "start": 147957, + "end": 147986 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxVecOperand_length", + "label": "_f3: EcxVecOperand_length", + "range": { + "start": 147991, + "end": 148035 + }, + "inputs": [ + "_t4" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_f1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_f1", + "to": "index", + "kind": "operand", + "index": 1 + }, + { + "from": "_t4", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "_t4", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "index", + "result", + "vec", + "_f1", + "_t2", + "_f3", + "_t4" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "result.handle().eq(&_f1.handle())", + "semantic_text": "result == _f1", + "referenced_vars": [ + "_f1", + "result" + ], + "range": { + "start": 148204, + "end": 148206 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "index.handle().eq(&_f3.handle())", + "semantic_text": "index == _f3", + "referenced_vars": [ + "_f3", + "index" + ], + "range": { + "start": 148224, + "end": 148226 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@240905:240931", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_vo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 240905, + "end": 240931 + } + }, + { + "id": "effect_1", + "effect_id": "effect@240941:240990", + "bound_var": null, + "source_text": "ctx.set_ecx_extracted_vec_operand(t1, pat.result)", + "semantic_text": "ecx_extracted_vec_operand(t1) = pat.result", + "referenced_pat_vars": [ + "result" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 240941, + "end": 240990 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0166", + "premises": [ + { + "target_id": "index", + "label": "index: ", + "plain_source": "upright(\"index\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $]" + }, + { + "target_id": "_f1", + "label": "_f1: EcxExtractedVecOperandHelper", + "plain_source": "upright(\"EcxExtractedVecOperandHelper\")(upright(\"VO\")(upright(\"vec\")), upright(\"index\"))", + "colored_source": "upright(\"EcxExtractedVecOperandHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $])" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxVecOperand_length", + "plain_source": "upright(\"EcxVecOperand_length\")(upright(\"VO\")(upright(\"vec\")))", + "colored_source": "upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + } + ], + "side_conditions": [ + "upright(\"result\") == upright(\"_f1\")", + "upright(\"index\") == upright(\"_f3\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "effect_1", + "plain_source": "upright(\"ecx_extracted_vec_operand\")(upright(\"EcxVo\")(upright(\"vec\"))) = upright(\"result\")", + "colored_source": "upright(\"ecx_extracted_vec_operand\")(upright(\"EcxVo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $])) = #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"result\") $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"index\") \\ upright(\"EcxExtractedVecOperandHelper\")(upright(\"VO\")(upright(\"vec\")), upright(\"index\")) \\ upright(\"VO\")(upright(\"vec\")) \\ upright(\"EcxVecOperand_length\")(upright(\"VO\")(upright(\"vec\"))) \\ upright(\"VO\")(upright(\"vec\")), upright(\"ecx_extracted_vec_operand\")(upright(\"EcxVo\")(upright(\"vec\"))) = upright(\"result\")) quad upright(\"if\") quad upright(\"result\") == upright(\"_f1\") \\ upright(\"index\") == upright(\"_f3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $] \\ upright(\"EcxExtractedVecOperandHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $] \\ upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], upright(\"ecx_extracted_vec_operand\")(upright(\"EcxVo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $])) = #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"result\") $]) quad upright(\"if\") quad upright(\"result\") == upright(\"_f1\") \\ upright(\"index\") == upright(\"_f3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7607_5_MyTxEggccExtraction_add_rule__r0167__723214558cd57605", + "display_name": "r0167", + "rule_name": "r0167", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 241004, + "line": 7607, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 241004, + "end": 241469 + }, + "pattern_range": { + "start": 241049, + "end": 241060 + }, + "action_range": { + "start": 241062, + "end": 241468 + } + }, + "nodes": [ + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperandBase", + "label": "vec: EcxVecVecOperandBase", + "range": { + "start": 148389, + "end": 148434 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t1: EcxVVO", + "range": { + "start": 148439, + "end": 148469 + }, + "inputs": [ + "vec" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "vec", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "vec", + "_t1" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@241092:241119", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_vvo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 241092, + "end": 241119 + } + }, + { + "id": "effect_1", + "effect_id": "effect@241138:241323", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_vvo(\n ctx.intern_container::>(\n VecContainer::::new(),\n ),\n )", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 241138, + "end": 241323 + } + }, + { + "id": "effect_2", + "effect_id": "effect@241342:241392", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_vec_vec_operand_and_cost(t3, 0_i64)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t3" + ], + "range": { + "start": 241342, + "end": 241392 + } + }, + { + "id": "effect_3", + "effect_id": "effect@241402:241461", + "bound_var": null, + "source_text": "ctx.set_ecx_extracted_vec_vec_operand_helper(t1, 0_i64, t2)", + "semantic_text": "ecx_extracted_vec_vec_operand_helper(t1, 0) = t2", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t1", + "t2" + ], + "range": { + "start": 241402, + "end": 241461 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0167", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_3", + "entry": { + "target_id": "effect:effect_3", + "label": "effect_3", + "plain_source": "upright(\"ecx_extracted_vec_vec_operand_helper\")(upright(\"EcxVvo\")(upright(\"vec\")), 0) = upright(\"VecVecOperandAndCost\")(upright(\"EcxVvo\")(upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"new\")())), 0)", + "colored_source": "upright(\"ecx_extracted_vec_vec_operand_helper\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 0 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"VecVecOperandAndCost\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"new\")()) $]), #text(fill: rgb(\"#B86A5B\"))[$ 0 $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"VVO\")(upright(\"vec\")), upright(\"ecx_extracted_vec_vec_operand_helper\")(upright(\"EcxVvo\")(upright(\"vec\")), 0) = upright(\"VecVecOperandAndCost\")(upright(\"EcxVvo\")(upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"new\")())), 0)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], upright(\"ecx_extracted_vec_vec_operand_helper\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 0 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"VecVecOperandAndCost\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"new\")()) $]), #text(fill: rgb(\"#B86A5B\"))[$ 0 $]) $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7617_5_MyTxEggccExtraction_add_rule__r0168__03c6fdd05a26a99d", + "display_name": "r0168", + "rule_name": "r0168", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 241475, + "line": 7617, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 241475, + "end": 242120 + }, + "pattern_range": { + "start": 241520, + "end": 241531 + }, + "action_range": { + "start": 241533, + "end": 242119 + } + }, + "nodes": [ + { + "id": "current", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperandBase", + "label": "current: EcxVecVecOperandBase", + "range": { + "start": 148989, + "end": 149038 + }, + "inputs": [] + }, + { + "id": "current_cost", + "kind": "query", + "dsl_type": "", + "label": "current_cost: ", + "range": { + "start": 149043, + "end": 149110 + }, + "inputs": [] + }, + { + "id": "expr", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "expr: EcxVecOperand", + "range": { + "start": 149115, + "end": 149154 + }, + "inputs": [] + }, + { + "id": "expr_cost", + "kind": "query", + "dsl_type": "", + "label": "expr_cost: ", + "range": { + "start": 149159, + "end": 149220 + }, + "inputs": [] + }, + { + "id": "index", + "kind": "query", + "dsl_type": "", + "label": "index: ", + "range": { + "start": 149225, + "end": 149278 + }, + "inputs": [] + }, + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperandBase", + "label": "vec: EcxVecVecOperandBase", + "range": { + "start": 149283, + "end": 149328 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t2: EcxVVO", + "range": { + "start": 149333, + "end": 149367 + }, + "inputs": [ + "current" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxVecVecOperandAndCost", + "label": "_t1: EcxVecVecOperandAndCost", + "range": { + "start": 149372, + "end": 149419 + }, + "inputs": [ + "_t2" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t4: EcxVVO", + "range": { + "start": 149424, + "end": 149454 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxExtractedVecVecOperandHelper", + "label": "_f3: EcxExtractedVecVecOperandHelper", + "range": { + "start": 149459, + "end": 149522 + }, + "inputs": [ + "_t4", + "index" + ] + }, + { + "id": "_t6", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t6: EcxVVO", + "range": { + "start": 149527, + "end": 149557 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_f5", + "kind": "query", + "dsl_type": "EcxVecVecOperand_length", + "label": "_f5: EcxVecVecOperand_length", + "range": { + "start": 149562, + "end": 149609 + }, + "inputs": [ + "_t6" + ] + }, + { + "id": "_t9", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t9: EcxVVO", + "range": { + "start": 149614, + "end": 149644 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_t8", + "kind": "query", + "dsl_type": "EcxVecVecOperand_get", + "label": "_t8: EcxVecVecOperand_get", + "range": { + "start": 149649, + "end": 149693 + }, + "inputs": [ + "_t9" + ] + }, + { + "id": "_f7", + "kind": "query", + "dsl_type": "EcxExtractedVecOperand", + "label": "_f7: EcxExtractedVecOperand", + "range": { + "start": 149698, + "end": 149744 + }, + "inputs": [ + "_t8" + ] + }, + { + "id": "_t10", + "kind": "query", + "dsl_type": "EcxVecOperandAndCost", + "label": "_t10: EcxVecOperandAndCost", + "range": { + "start": 149749, + "end": 149795 + }, + "inputs": [ + "expr" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "current", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "_t4", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "index", + "kind": "operand", + "index": 1 + }, + { + "from": "_t6", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_f5", + "to": "_t6", + "kind": "operand", + "index": 0 + }, + { + "from": "_t9", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_t8", + "to": "_t9", + "kind": "operand", + "index": 0 + }, + { + "from": "_f7", + "to": "_t8", + "kind": "operand", + "index": 0 + }, + { + "from": "_t10", + "to": "expr", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "current", + "current_cost", + "expr", + "expr_cost", + "index", + "vec", + "_t1", + "_t2", + "_f3", + "_t4", + "_f5", + "_t6", + "_f7", + "_t8", + "_t9", + "_t10" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "current_cost.handle().eq(&_t1.handle_a1())", + "semantic_text": "current_cost == _t1.a1", + "referenced_vars": [ + "_t1", + "current_cost" + ], + "range": { + "start": 150363, + "end": 150365 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "_t1.handle().eq(&_f3.handle())", + "semantic_text": "_t1 == _f3", + "referenced_vars": [ + "_f3", + "_t1" + ], + "range": { + "start": 150379, + "end": 150381 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "index.handle().lt(&_f5.handle())", + "semantic_text": "index < _f5", + "referenced_vars": [ + "_f5", + "index" + ], + "range": { + "start": 150395, + "end": 150397 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "index.handle().eq(&_t8.handle_a1())", + "semantic_text": "index == _t8.a1", + "referenced_vars": [ + "_t8", + "index" + ], + "range": { + "start": 150411, + "end": 150413 + } + }, + { + "id": "constraint_4", + "source_text": "c4", + "resolved_text": "expr_cost.handle().eq(&_t10.handle_a1())", + "semantic_text": "expr_cost == _t10.a1", + "referenced_vars": [ + "_t10", + "expr_cost" + ], + "range": { + "start": 150427, + "end": 150429 + } + }, + { + "id": "constraint_5", + "source_text": "c5", + "resolved_text": "_f7.handle().eq(&_t10.handle())", + "semantic_text": "_f7 == _t10", + "referenced_vars": [ + "_f7", + "_t10" + ], + "range": { + "start": 150443, + "end": 150445 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@241563:241590", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_vvo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 241563, + "end": 241590 + } + }, + { + "id": "effect_1", + "effect_id": "effect@241621:241857", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_vvo(\n ctx.intern_container::>(\n vec_push::(&*ctx.devalue(pat.current), pat.expr.erase()),\n ),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "current", + "expr" + ], + "referenced_action_vars": [], + "range": { + "start": 241621, + "end": 241857 + } + }, + { + "id": "effect_2", + "effect_id": "effect@241876:242016", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_vec_vec_operand_and_cost(\n t3,\n (ctx.devalue(pat.current_cost) + ctx.devalue(pat.expr_cost)),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "current_cost", + "expr_cost" + ], + "referenced_action_vars": [ + "t3" + ], + "range": { + "start": 241876, + "end": 242016 + } + }, + { + "id": "effect_3", + "effect_id": "effect@242026:242112", + "bound_var": null, + "source_text": "ctx.set_ecx_extracted_vec_vec_operand_helper(t1, (ctx.devalue(pat.index) + 1_i64), t2)", + "semantic_text": "ecx_extracted_vec_vec_operand_helper(t1, ctx.devalue(pat.index) + 1) = t2", + "referenced_pat_vars": [ + "index" + ], + "referenced_action_vars": [ + "t1", + "t2" + ], + "range": { + "start": 242026, + "end": 242112 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0168", + "premises": [ + { + "target_id": "current_cost", + "label": "current_cost: ", + "plain_source": "upright(\"current_cost\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"current_cost\") $]" + }, + { + "target_id": "expr_cost", + "label": "expr_cost: ", + "plain_source": "upright(\"expr_cost\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr_cost\") $]" + }, + { + "target_id": "index", + "label": "index: ", + "plain_source": "upright(\"index\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxVecVecOperandAndCost", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"current\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"current\") $]) $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxExtractedVecVecOperandHelper", + "plain_source": "upright(\"EcxExtractedVecVecOperandHelper\")(upright(\"VVO\")(upright(\"vec\")), upright(\"index\"))", + "colored_source": "upright(\"EcxExtractedVecVecOperandHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + }, + { + "target_id": "_f5", + "label": "_f5: EcxVecVecOperand_length", + "plain_source": "upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(upright(\"vec\")))", + "colored_source": "upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $])" + }, + { + "target_id": "_t6", + "label": "_t6: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + }, + { + "target_id": "_f7", + "label": "_f7: EcxExtractedVecOperand", + "plain_source": "upright(\"EcxExtractedVecOperand\")(upright(\"_t8\"))", + "colored_source": "upright(\"EcxExtractedVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t8\") $])" + }, + { + "target_id": "_t8", + "label": "_t8: EcxVecVecOperand_get", + "plain_source": "upright(\"_t8\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t8\") $]" + }, + { + "target_id": "_t9", + "label": "_t9: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + }, + { + "target_id": "_t10", + "label": "_t10: EcxVecOperandAndCost", + "plain_source": "upright(\"_t10\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $]" + } + ], + "side_conditions": [ + "upright(\"current_cost\") == upright(\"_t1.a1\")", + "upright(\"_t1\") == upright(\"_f3\")", + "upright(\"index\") < upright(\"_f5\")", + "upright(\"index\") == upright(\"_t8.a1\")", + "upright(\"expr_cost\") == upright(\"_t10.a1\")", + "upright(\"_f7\") == upright(\"_t10\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_3", + "entry": { + "target_id": "effect:effect_3", + "label": "effect_3", + "plain_source": "upright(\"ecx_extracted_vec_vec_operand_helper\")(upright(\"EcxVvo\")(upright(\"vec\")), upright(\"index\") + 1) = upright(\"VecVecOperandAndCost\")(upright(\"EcxVvo\")(upright(\"intern_container\")::>(upright(\"vec_push\")::(*upright(\"current\"), upright(\"expr.erase\")()))), upright(\"current_cost\") + upright(\"expr_cost\"))", + "colored_source": "upright(\"ecx_extracted_vec_vec_operand_helper\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]), #text(fill: rgb(\"#B86A5B\"))[$ upright(\"index\") + 1 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"VecVecOperandAndCost\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"vec_push\")::(*upright(\"current\"), upright(\"expr.erase\")())) $]), #text(fill: rgb(\"#B86A5B\"))[$ upright(\"current_cost\") + upright(\"expr_cost\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"current_cost\") \\ upright(\"expr_cost\") \\ upright(\"index\") \\ upright(\"_t1\") \\ upright(\"VVO\")(upright(\"current\")) \\ upright(\"EcxExtractedVecVecOperandHelper\")(upright(\"VVO\")(upright(\"vec\")), upright(\"index\")) \\ upright(\"VVO\")(upright(\"vec\")) \\ upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(upright(\"vec\"))) \\ upright(\"VVO\")(upright(\"vec\")) \\ upright(\"EcxExtractedVecOperand\")(upright(\"_t8\")) \\ upright(\"_t8\") \\ upright(\"VVO\")(upright(\"vec\")) \\ upright(\"_t10\"), upright(\"ecx_extracted_vec_vec_operand_helper\")(upright(\"EcxVvo\")(upright(\"vec\")), upright(\"index\") + 1) = upright(\"VecVecOperandAndCost\")(upright(\"EcxVvo\")(upright(\"intern_container\")::>(upright(\"vec_push\")::(*upright(\"current\"), upright(\"expr.erase\")()))), upright(\"current_cost\") + upright(\"expr_cost\"))) quad upright(\"if\") quad upright(\"current_cost\") == upright(\"_t1.a1\") \\ upright(\"_t1\") == upright(\"_f3\") \\ upright(\"index\") < upright(\"_f5\") \\ upright(\"index\") == upright(\"_t8.a1\") \\ upright(\"expr_cost\") == upright(\"_t10.a1\") \\ upright(\"_f7\") == upright(\"_t10\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"current_cost\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr_cost\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"current\") $]) $] \\ upright(\"EcxExtractedVecVecOperandHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $] \\ upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $] \\ upright(\"EcxExtractedVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t8\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t8\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], upright(\"ecx_extracted_vec_vec_operand_helper\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]), #text(fill: rgb(\"#B86A5B\"))[$ upright(\"index\") + 1 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"VecVecOperandAndCost\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"vec_push\")::(*upright(\"current\"), upright(\"expr.erase\")())) $]), #text(fill: rgb(\"#B86A5B\"))[$ upright(\"current_cost\") + upright(\"expr_cost\") $]) $]) quad upright(\"if\") quad upright(\"current_cost\") == upright(\"_t1.a1\") \\ upright(\"_t1\") == upright(\"_f3\") \\ upright(\"index\") < upright(\"_f5\") \\ upright(\"index\") == upright(\"_t8.a1\") \\ upright(\"expr_cost\") == upright(\"_t10.a1\") \\ upright(\"_f7\") == upright(\"_t10\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7631_5_MyTxEggccExtraction_add_rule__r0169__aa8657ac199c96ca", + "display_name": "r0169", + "rule_name": "r0169", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 242126, + "line": 7631, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 242126, + "end": 242312 + }, + "pattern_range": { + "start": 242171, + "end": 242182 + }, + "action_range": { + "start": 242184, + "end": 242311 + } + }, + "nodes": [ + { + "id": "index", + "kind": "query", + "dsl_type": "", + "label": "index: ", + "range": { + "start": 150708, + "end": 150761 + }, + "inputs": [] + }, + { + "id": "result", + "kind": "query_leaf", + "dsl_type": "EcxTermAndCost", + "label": "result: EcxTermAndCost", + "range": { + "start": 150766, + "end": 150808 + }, + "inputs": [] + }, + { + "id": "vec", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperandBase", + "label": "vec: EcxVecVecOperandBase", + "range": { + "start": 150813, + "end": 150858 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t2: EcxVVO", + "range": { + "start": 150863, + "end": 150893 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_f1", + "kind": "query", + "dsl_type": "EcxExtractedVecVecOperandHelper", + "label": "_f1: EcxExtractedVecVecOperandHelper", + "range": { + "start": 150898, + "end": 150961 + }, + "inputs": [ + "_t2", + "index" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t4: EcxVVO", + "range": { + "start": 150966, + "end": 150996 + }, + "inputs": [ + "vec" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxVecVecOperand_length", + "label": "_f3: EcxVecVecOperand_length", + "range": { + "start": 151001, + "end": 151048 + }, + "inputs": [ + "_t4" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_f1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_f1", + "to": "index", + "kind": "operand", + "index": 1 + }, + { + "from": "_t4", + "to": "vec", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "_t4", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "index", + "result", + "vec", + "_f1", + "_t2", + "_f3", + "_t4" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "result.handle().eq(&_f1.handle())", + "semantic_text": "result == _f1", + "referenced_vars": [ + "_f1", + "result" + ], + "range": { + "start": 151217, + "end": 151219 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "index.handle().eq(&_f3.handle())", + "semantic_text": "index == _f3", + "referenced_vars": [ + "_f3", + "index" + ], + "range": { + "start": 151237, + "end": 151239 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@242214:242241", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_vvo(pat.vec)", + "semantic_text": null, + "referenced_pat_vars": [ + "vec" + ], + "referenced_action_vars": [], + "range": { + "start": 242214, + "end": 242241 + } + }, + { + "id": "effect_1", + "effect_id": "effect@242251:242304", + "bound_var": null, + "source_text": "ctx.set_ecx_extracted_vec_vec_operand(t1, pat.result)", + "semantic_text": "ecx_extracted_vec_vec_operand(t1) = pat.result", + "referenced_pat_vars": [ + "result" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 242251, + "end": 242304 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0169", + "premises": [ + { + "target_id": "index", + "label": "index: ", + "plain_source": "upright(\"index\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $]" + }, + { + "target_id": "_f1", + "label": "_f1: EcxExtractedVecVecOperandHelper", + "plain_source": "upright(\"EcxExtractedVecVecOperandHelper\")(upright(\"VVO\")(upright(\"vec\")), upright(\"index\"))", + "colored_source": "upright(\"EcxExtractedVecVecOperandHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $])" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxVecVecOperand_length", + "plain_source": "upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(upright(\"vec\")))", + "colored_source": "upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"vec\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]" + } + ], + "side_conditions": [ + "upright(\"result\") == upright(\"_f1\")", + "upright(\"index\") == upright(\"_f3\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "effect_1", + "plain_source": "upright(\"ecx_extracted_vec_vec_operand\")(upright(\"EcxVvo\")(upright(\"vec\"))) = upright(\"result\")", + "colored_source": "upright(\"ecx_extracted_vec_vec_operand\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $])) = #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"result\") $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"index\") \\ upright(\"EcxExtractedVecVecOperandHelper\")(upright(\"VVO\")(upright(\"vec\")), upright(\"index\")) \\ upright(\"VVO\")(upright(\"vec\")) \\ upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(upright(\"vec\"))) \\ upright(\"VVO\")(upright(\"vec\")), upright(\"ecx_extracted_vec_vec_operand\")(upright(\"EcxVvo\")(upright(\"vec\"))) = upright(\"result\")) quad upright(\"if\") quad upright(\"result\") == upright(\"_f1\") \\ upright(\"index\") == upright(\"_f3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $] \\ upright(\"EcxExtractedVecVecOperandHelper\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $] \\ upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $]) $], upright(\"ecx_extracted_vec_vec_operand\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"vec\") $])) = #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"result\") $]) quad upright(\"if\") quad upright(\"result\") == upright(\"_f1\") \\ upright(\"index\") == upright(\"_f3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7635_5_MyTxEggccExtraction_add_rule__r0170__ba7cd69888a058b0", + "display_name": "r0170", + "rule_name": "r0170", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 242318, + "line": 7635, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 242318, + "end": 242507 + }, + "pattern_range": { + "start": 242363, + "end": 242374 + }, + "action_range": { + "start": 242376, + "end": 242506 + } + }, + "nodes": [ + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "lhs: EcxExpr", + "range": { + "start": 151451, + "end": 151483 + }, + "inputs": [] + }, + { + "id": "lit", + "kind": "query_leaf", + "dsl_type": "EcxLiteral", + "label": "lit: EcxLiteral", + "range": { + "start": 151488, + "end": 151523 + }, + "inputs": [] + }, + { + "id": "ops", + "kind": "query_leaf", + "dsl_type": "EcxConstOps", + "label": "ops: EcxConstOps", + "range": { + "start": 151528, + "end": 151564 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxType", + "label": "ty: EcxType", + "range": { + "start": 151569, + "end": 151600 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxConst", + "label": "_t1: EcxConst", + "range": { + "start": 151605, + "end": 151648 + }, + "inputs": [ + "ty", + "ops", + "lit" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "ops", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "lit", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "lhs", + "lit", + "ops", + "ty", + "_t1" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 151742, + "end": 151744 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@242406:242450", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_expr_and_cost(pat.lhs, 1_i64)", + "semantic_text": null, + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [], + "range": { + "start": 242406, + "end": 242450 + } + }, + { + "id": "effect_1", + "effect_id": "effect@242460:242499", + "bound_var": null, + "source_text": "ctx.set_ecx_extracted_expr(pat.lhs, t1)", + "semantic_text": "ecx_extracted_expr(pat.lhs) = t1", + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 242460, + "end": 242499 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0170", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxConst", + "plain_source": "upright(\"Const\")(upright(\"ty\"), upright(\"ops\"), upright(\"lit\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lit\") $]) $]" + } + ], + "side_conditions": [ + "upright(\"lhs\") == upright(\"_t1\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "effect_1", + "plain_source": "upright(\"ecx_extracted_expr\")(upright(\"lhs\")) = upright(\"ExprAndCost\")(upright(\"lhs\"), 1)", + "colored_source": "upright(\"ecx_extracted_expr\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"ExprAndCost\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $], #text(fill: rgb(\"#B86A5B\"))[$ 1 $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"Const\")(upright(\"ty\"), upright(\"ops\"), upright(\"lit\")), upright(\"ecx_extracted_expr\")(upright(\"lhs\")) = upright(\"ExprAndCost\")(upright(\"lhs\"), 1)) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ty\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ops\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lit\") $]) $], upright(\"ecx_extracted_expr\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"ExprAndCost\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $], #text(fill: rgb(\"#B86A5B\"))[$ 1 $]) $]) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7639_5_MyTxEggccExtraction_add_rule__r0171__1b46d23da14fdb27", + "display_name": "r0171", + "rule_name": "r0171", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 242513, + "line": 7639, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 242513, + "end": 242708 + }, + "pattern_range": { + "start": 242558, + "end": 242569 + }, + "action_range": { + "start": 242571, + "end": 242707 + } + }, + "nodes": [ + { + "id": "index", + "kind": "query", + "dsl_type": "", + "label": "index: ", + "range": { + "start": 151913, + "end": 151966 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "lhs: EcxOperand", + "range": { + "start": 151971, + "end": 152006 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxArg", + "label": "_t1: EcxArg", + "range": { + "start": 152011, + "end": 152037 + }, + "inputs": [] + } + ], + "edges": [], + "roots": [ + "index", + "lhs", + "_t1" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "index.handle().eq(&_t1.handle_a0())", + "semantic_text": "index == _t1.a0", + "referenced_vars": [ + "_t1", + "index" + ], + "range": { + "start": 152174, + "end": 152176 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 152185, + "end": 152187 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@242601:242648", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_operand_and_cost(pat.lhs, 1_i64)", + "semantic_text": null, + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [], + "range": { + "start": 242601, + "end": 242648 + } + }, + { + "id": "effect_1", + "effect_id": "effect@242658:242700", + "bound_var": null, + "source_text": "ctx.set_ecx_extracted_operand(pat.lhs, t1)", + "semantic_text": "ecx_extracted_operand(pat.lhs) = t1", + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 242658, + "end": 242700 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0171", + "premises": [ + { + "target_id": "index", + "label": "index: ", + "plain_source": "upright(\"index\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxArg", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + } + ], + "side_conditions": [ + "upright(\"index\") == upright(\"_t1.a0\")", + "upright(\"lhs\") == upright(\"_t1\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "effect_1", + "plain_source": "upright(\"ecx_extracted_operand\")(upright(\"lhs\")) = upright(\"OperandAndCost\")(upright(\"lhs\"), 1)", + "colored_source": "upright(\"ecx_extracted_operand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandAndCost\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $], #text(fill: rgb(\"#B86A5B\"))[$ 1 $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"index\") \\ upright(\"_t1\"), upright(\"ecx_extracted_operand\")(upright(\"lhs\")) = upright(\"OperandAndCost\")(upright(\"lhs\"), 1)) quad upright(\"if\") quad upright(\"index\") == upright(\"_t1.a0\") \\ upright(\"lhs\") == upright(\"_t1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $], upright(\"ecx_extracted_operand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandAndCost\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $], #text(fill: rgb(\"#B86A5B\"))[$ 1 $]) $]) quad upright(\"if\") quad upright(\"index\") == upright(\"_t1.a0\") \\ upright(\"lhs\") == upright(\"_t1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7643_5_MyTxEggccExtraction_add_rule__r0172__3ea0155787428c3b", + "display_name": "r0172", + "rule_name": "r0172", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 242714, + "line": 7643, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 242714, + "end": 242980 + }, + "pattern_range": { + "start": 242759, + "end": 242770 + }, + "action_range": { + "start": 242772, + "end": 242979 + } + }, + "nodes": [ + { + "id": "expr", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "expr: EcxExpr", + "range": { + "start": 152458, + "end": 152491 + }, + "inputs": [] + }, + { + "id": "expr_cost", + "kind": "query", + "dsl_type": "", + "label": "expr_cost: ", + "range": { + "start": 152496, + "end": 152557 + }, + "inputs": [] + }, + { + "id": "expr_extracted", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "expr_extracted: EcxExpr", + "range": { + "start": 152562, + "end": 152605 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "lhs: EcxBody", + "range": { + "start": 152610, + "end": 152642 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t1: EcxPureOp", + "range": { + "start": 152647, + "end": 152681 + }, + "inputs": [ + "expr" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxExprAndCost", + "label": "_t2: EcxExprAndCost", + "range": { + "start": 152686, + "end": 152735 + }, + "inputs": [ + "expr_extracted" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxExtractedExpr", + "label": "_f3: EcxExtractedExpr", + "range": { + "start": 152740, + "end": 152781 + }, + "inputs": [ + "expr" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "expr", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "expr_extracted", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "expr", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "expr", + "expr_cost", + "expr_extracted", + "lhs", + "_t1", + "_t2", + "_f3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 153012, + "end": 153014 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "expr_cost.handle().eq(&_t2.handle_a1())", + "semantic_text": "expr_cost == _t2.a1", + "referenced_vars": [ + "_t2", + "expr_cost" + ], + "range": { + "start": 153032, + "end": 153034 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "_t2.handle().eq(&_f3.handle())", + "semantic_text": "_t2 == _f3", + "referenced_vars": [ + "_f3", + "_t2" + ], + "range": { + "start": 153052, + "end": 153054 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@242802:242844", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_pure_op(pat.expr_extracted)", + "semantic_text": null, + "referenced_pat_vars": [ + "expr_extracted" + ], + "referenced_action_vars": [], + "range": { + "start": 242802, + "end": 242844 + } + }, + { + "id": "effect_1", + "effect_id": "effect@242863:242923", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_body_and_cost(t2, ctx.devalue(pat.expr_cost))", + "semantic_text": null, + "referenced_pat_vars": [ + "expr_cost" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 242863, + "end": 242923 + } + }, + { + "id": "effect_2", + "effect_id": "effect@242933:242972", + "bound_var": null, + "source_text": "ctx.set_ecx_extracted_body(pat.lhs, t1)", + "semantic_text": "ecx_extracted_body(pat.lhs) = t1", + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 242933, + "end": 242972 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0172", + "premises": [ + { + "target_id": "expr_cost", + "label": "expr_cost: ", + "plain_source": "upright(\"expr_cost\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr_cost\") $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxPureOp", + "plain_source": "upright(\"PureOp\")(upright(\"expr\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxExprAndCost", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxExtractedExpr", + "plain_source": "upright(\"EcxExtractedExpr\")(upright(\"expr\"))", + "colored_source": "upright(\"EcxExtractedExpr\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $])" + } + ], + "side_conditions": [ + "upright(\"lhs\") == upright(\"_t1\")", + "upright(\"expr_cost\") == upright(\"_t2.a1\")", + "upright(\"_t2\") == upright(\"_f3\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_2", + "entry": { + "target_id": "effect:effect_2", + "label": "effect_2", + "plain_source": "upright(\"ecx_extracted_body\")(upright(\"lhs\")) = upright(\"BodyAndCost\")((upright(\"PureOp\")(upright(\"expr_extracted\"))), upright(\"expr_cost\"))", + "colored_source": "upright(\"ecx_extracted_body\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"BodyAndCost\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr_extracted\") $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr_cost\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"expr_cost\") \\ upright(\"PureOp\")(upright(\"expr\")) \\ upright(\"_t2\") \\ upright(\"EcxExtractedExpr\")(upright(\"expr\")), upright(\"ecx_extracted_body\")(upright(\"lhs\")) = upright(\"BodyAndCost\")((upright(\"PureOp\")(upright(\"expr_extracted\"))), upright(\"expr_cost\"))) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\") \\ upright(\"expr_cost\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr_cost\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ upright(\"EcxExtractedExpr\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $]), upright(\"ecx_extracted_body\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"BodyAndCost\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr_extracted\") $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr_cost\") $]) $]) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\") \\ upright(\"expr_cost\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7648_5_MyTxEggccExtraction_add_rule__r0173__349e57c36bb13461", + "display_name": "r0173", + "rule_name": "r0173", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 242986, + "line": 7648, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 242986, + "end": 243255 + }, + "pattern_range": { + "start": 243031, + "end": 243042 + }, + "action_range": { + "start": 243044, + "end": 243254 + } + }, + "nodes": [ + { + "id": "body", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "body: EcxBody", + "range": { + "start": 153326, + "end": 153359 + }, + "inputs": [] + }, + { + "id": "body_cost", + "kind": "query", + "dsl_type": "", + "label": "body_cost: ", + "range": { + "start": 153364, + "end": 153425 + }, + "inputs": [] + }, + { + "id": "body_extracted", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "body_extracted: EcxBody", + "range": { + "start": 153430, + "end": 153473 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "lhs: EcxOperand", + "range": { + "start": 153478, + "end": 153513 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t1: EcxNode", + "range": { + "start": 153518, + "end": 153550 + }, + "inputs": [ + "body" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxBodyAndCost", + "label": "_t2: EcxBodyAndCost", + "range": { + "start": 153555, + "end": 153604 + }, + "inputs": [ + "body_extracted" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxExtractedBody", + "label": "_f3: EcxExtractedBody", + "range": { + "start": 153609, + "end": 153650 + }, + "inputs": [ + "body" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "body", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "body_extracted", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "body", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "body", + "body_cost", + "body_extracted", + "lhs", + "_t1", + "_t2", + "_f3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 153881, + "end": 153883 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "body_cost.handle().eq(&_t2.handle_a1())", + "semantic_text": "body_cost == _t2.a1", + "referenced_vars": [ + "_t2", + "body_cost" + ], + "range": { + "start": 153901, + "end": 153903 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "_t2.handle().eq(&_f3.handle())", + "semantic_text": "_t2 == _f3", + "referenced_vars": [ + "_f3", + "_t2" + ], + "range": { + "start": 153921, + "end": 153923 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@243074:243113", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_node(pat.body_extracted)", + "semantic_text": null, + "referenced_pat_vars": [ + "body_extracted" + ], + "referenced_action_vars": [], + "range": { + "start": 243074, + "end": 243113 + } + }, + { + "id": "effect_1", + "effect_id": "effect@243132:243195", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_operand_and_cost(t2, ctx.devalue(pat.body_cost))", + "semantic_text": null, + "referenced_pat_vars": [ + "body_cost" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 243132, + "end": 243195 + } + }, + { + "id": "effect_2", + "effect_id": "effect@243205:243247", + "bound_var": null, + "source_text": "ctx.set_ecx_extracted_operand(pat.lhs, t1)", + "semantic_text": "ecx_extracted_operand(pat.lhs) = t1", + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 243205, + "end": 243247 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0173", + "premises": [ + { + "target_id": "body_cost", + "label": "body_cost: ", + "plain_source": "upright(\"body_cost\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body_cost\") $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxNode", + "plain_source": "upright(\"Node\")(upright(\"body\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxBodyAndCost", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxExtractedBody", + "plain_source": "upright(\"EcxExtractedBody\")(upright(\"body\"))", + "colored_source": "upright(\"EcxExtractedBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $])" + } + ], + "side_conditions": [ + "upright(\"lhs\") == upright(\"_t1\")", + "upright(\"body_cost\") == upright(\"_t2.a1\")", + "upright(\"_t2\") == upright(\"_f3\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_2", + "entry": { + "target_id": "effect:effect_2", + "label": "effect_2", + "plain_source": "upright(\"ecx_extracted_operand\")(upright(\"lhs\")) = upright(\"OperandAndCost\")((upright(\"Node\")(upright(\"body_extracted\"))), upright(\"body_cost\"))", + "colored_source": "upright(\"ecx_extracted_operand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandAndCost\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Node\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body_extracted\") $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body_cost\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"body_cost\") \\ upright(\"Node\")(upright(\"body\")) \\ upright(\"_t2\") \\ upright(\"EcxExtractedBody\")(upright(\"body\")), upright(\"ecx_extracted_operand\")(upright(\"lhs\")) = upright(\"OperandAndCost\")((upright(\"Node\")(upright(\"body_extracted\"))), upright(\"body_cost\"))) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\") \\ upright(\"body_cost\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body_cost\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ upright(\"EcxExtractedBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $]), upright(\"ecx_extracted_operand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandAndCost\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Node\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body_extracted\") $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body_cost\") $]) $]) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\") \\ upright(\"body_cost\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7653_5_MyTxEggccExtraction_add_rule__r0174__74da94698c5c5aa0", + "display_name": "r0174", + "rule_name": "r0174", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 243261, + "line": 7653, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 243261, + "end": 243765 + }, + "pattern_range": { + "start": 243306, + "end": 243317 + }, + "action_range": { + "start": 243319, + "end": 243764 + } + }, + "nodes": [ + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 154489, + "end": 154530 + }, + "inputs": [] + }, + { + "id": "inputs_cost", + "kind": "query", + "dsl_type": "", + "label": "inputs_cost: ", + "range": { + "start": 154535, + "end": 154600 + }, + "inputs": [] + }, + { + "id": "inputs_extracted", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs_extracted: EcxVecOperand", + "range": { + "start": 154605, + "end": 154656 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "lhs: EcxBody", + "range": { + "start": 154661, + "end": 154693 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "outputs: EcxVecOperand", + "range": { + "start": 154698, + "end": 154740 + }, + "inputs": [] + }, + { + "id": "outputs_cost", + "kind": "query", + "dsl_type": "", + "label": "outputs_cost: ", + "range": { + "start": 154745, + "end": 154812 + }, + "inputs": [] + }, + { + "id": "outputs_extracted", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "outputs_extracted: EcxVecOperand", + "range": { + "start": 154817, + "end": 154869 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 154874, + "end": 154910 + }, + "inputs": [] + }, + { + "id": "pred_cost", + "kind": "query", + "dsl_type": "", + "label": "pred_cost: ", + "range": { + "start": 154915, + "end": 154976 + }, + "inputs": [] + }, + { + "id": "pred_extracted", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred_extracted: EcxOperand", + "range": { + "start": 154981, + "end": 155027 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxTheta", + "label": "_t1: EcxTheta", + "range": { + "start": 155032, + "end": 155084 + }, + "inputs": [ + "pred", + "inputs", + "outputs" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxOperandAndCost", + "label": "_t2: EcxOperandAndCost", + "range": { + "start": 155089, + "end": 155141 + }, + "inputs": [ + "pred_extracted" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxExtractedOperand", + "label": "_f3: EcxExtractedOperand", + "range": { + "start": 155146, + "end": 155190 + }, + "inputs": [ + "pred" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxVecOperandAndCost", + "label": "_t4: EcxVecOperandAndCost", + "range": { + "start": 155195, + "end": 155252 + }, + "inputs": [ + "inputs_extracted" + ] + }, + { + "id": "_f5", + "kind": "query", + "dsl_type": "EcxExtractedVecOperand", + "label": "_f5: EcxExtractedVecOperand", + "range": { + "start": 155257, + "end": 155306 + }, + "inputs": [ + "inputs" + ] + }, + { + "id": "_t6", + "kind": "query", + "dsl_type": "EcxVecOperandAndCost", + "label": "_t6: EcxVecOperandAndCost", + "range": { + "start": 155311, + "end": 155369 + }, + "inputs": [ + "outputs_extracted" + ] + }, + { + "id": "_f7", + "kind": "query", + "dsl_type": "EcxExtractedVecOperand", + "label": "_f7: EcxExtractedVecOperand", + "range": { + "start": 155374, + "end": 155424 + }, + "inputs": [ + "outputs" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "outputs", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "pred_extracted", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "inputs_extracted", + "kind": "operand", + "index": 0 + }, + { + "from": "_f5", + "to": "inputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t6", + "to": "outputs_extracted", + "kind": "operand", + "index": 0 + }, + { + "from": "_f7", + "to": "outputs", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "inputs", + "inputs_cost", + "inputs_extracted", + "lhs", + "outputs", + "outputs_cost", + "outputs_extracted", + "pred", + "pred_cost", + "pred_extracted", + "_t1", + "_t2", + "_f3", + "_t4", + "_f5", + "_t6", + "_f7" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 156098, + "end": 156100 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "pred_cost.handle().eq(&_t2.handle_a1())", + "semantic_text": "pred_cost == _t2.a1", + "referenced_vars": [ + "_t2", + "pred_cost" + ], + "range": { + "start": 156114, + "end": 156116 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "_t2.handle().eq(&_f3.handle())", + "semantic_text": "_t2 == _f3", + "referenced_vars": [ + "_f3", + "_t2" + ], + "range": { + "start": 156130, + "end": 156132 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "inputs_cost.handle().eq(&_t4.handle_a1())", + "semantic_text": "inputs_cost == _t4.a1", + "referenced_vars": [ + "_t4", + "inputs_cost" + ], + "range": { + "start": 156146, + "end": 156148 + } + }, + { + "id": "constraint_4", + "source_text": "c4", + "resolved_text": "_t4.handle().eq(&_f5.handle())", + "semantic_text": "_t4 == _f5", + "referenced_vars": [ + "_f5", + "_t4" + ], + "range": { + "start": 156162, + "end": 156164 + } + }, + { + "id": "constraint_5", + "source_text": "c5", + "resolved_text": "outputs_cost.handle().eq(&_t6.handle_a1())", + "semantic_text": "outputs_cost == _t6.a1", + "referenced_vars": [ + "_t6", + "outputs_cost" + ], + "range": { + "start": 156178, + "end": 156180 + } + }, + { + "id": "constraint_6", + "source_text": "c6", + "resolved_text": "_t6.handle().eq(&_f7.handle())", + "semantic_text": "_t6 == _f7", + "referenced_vars": [ + "_f7", + "_t6" + ], + "range": { + "start": 156194, + "end": 156196 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@243349:243481", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_theta(\n pat.pred_extracted,\n pat.inputs_extracted,\n pat.outputs_extracted,\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "inputs_extracted", + "outputs_extracted", + "pred_extracted" + ], + "referenced_action_vars": [], + "range": { + "start": 243349, + "end": 243481 + } + }, + { + "id": "effect_1", + "effect_id": "effect@243500:243708", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_body_and_cost(\n t2,\n (1_i64\n + (ctx.devalue(pat.pred_cost)\n + (ctx.devalue(pat.inputs_cost) + ctx.devalue(pat.outputs_cost)))),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "inputs_cost", + "outputs_cost", + "pred_cost" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 243500, + "end": 243708 + } + }, + { + "id": "effect_2", + "effect_id": "effect@243718:243757", + "bound_var": null, + "source_text": "ctx.set_ecx_extracted_body(pat.lhs, t1)", + "semantic_text": "ecx_extracted_body(pat.lhs) = t1", + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 243718, + "end": 243757 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0174", + "premises": [ + { + "target_id": "inputs_cost", + "label": "inputs_cost: ", + "plain_source": "upright(\"inputs_cost\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs_cost\") $]" + }, + { + "target_id": "outputs_cost", + "label": "outputs_cost: ", + "plain_source": "upright(\"outputs_cost\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs_cost\") $]" + }, + { + "target_id": "pred_cost", + "label": "pred_cost: ", + "plain_source": "upright(\"pred_cost\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred_cost\") $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxTheta", + "plain_source": "upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxOperandAndCost", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxExtractedOperand", + "plain_source": "upright(\"EcxExtractedOperand\")(upright(\"pred\"))", + "colored_source": "upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxVecOperandAndCost", + "plain_source": "upright(\"_t4\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $]" + }, + { + "target_id": "_f5", + "label": "_f5: EcxExtractedVecOperand", + "plain_source": "upright(\"EcxExtractedVecOperand\")(upright(\"inputs\"))", + "colored_source": "upright(\"EcxExtractedVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $])" + }, + { + "target_id": "_t6", + "label": "_t6: EcxVecOperandAndCost", + "plain_source": "upright(\"_t6\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]" + }, + { + "target_id": "_f7", + "label": "_f7: EcxExtractedVecOperand", + "plain_source": "upright(\"EcxExtractedVecOperand\")(upright(\"outputs\"))", + "colored_source": "upright(\"EcxExtractedVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $])" + } + ], + "side_conditions": [ + "upright(\"lhs\") == upright(\"_t1\")", + "upright(\"pred_cost\") == upright(\"_t2.a1\")", + "upright(\"_t2\") == upright(\"_f3\")", + "upright(\"inputs_cost\") == upright(\"_t4.a1\")", + "upright(\"_t4\") == upright(\"_f5\")", + "upright(\"outputs_cost\") == upright(\"_t6.a1\")", + "upright(\"_t6\") == upright(\"_f7\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_2", + "entry": { + "target_id": "effect:effect_2", + "label": "effect_2", + "plain_source": "upright(\"ecx_extracted_body\")(upright(\"lhs\")) = upright(\"BodyAndCost\")((upright(\"Theta\")(upright(\"pred_extracted\"), upright(\"inputs_extracted\"), upright(\"outputs_extracted\"))), 1 + upright(\"pred_cost\") + upright(\"inputs_cost\") + upright(\"outputs_cost\"))", + "colored_source": "upright(\"ecx_extracted_body\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"BodyAndCost\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred_extracted\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs_extracted\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs_extracted\") $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ 1 + upright(\"pred_cost\") + upright(\"inputs_cost\") + upright(\"outputs_cost\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"inputs_cost\") \\ upright(\"outputs_cost\") \\ upright(\"pred_cost\") \\ upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\")) \\ upright(\"_t2\") \\ upright(\"EcxExtractedOperand\")(upright(\"pred\")) \\ upright(\"_t4\") \\ upright(\"EcxExtractedVecOperand\")(upright(\"inputs\")) \\ upright(\"_t6\") \\ upright(\"EcxExtractedVecOperand\")(upright(\"outputs\")), upright(\"ecx_extracted_body\")(upright(\"lhs\")) = upright(\"BodyAndCost\")((upright(\"Theta\")(upright(\"pred_extracted\"), upright(\"inputs_extracted\"), upright(\"outputs_extracted\"))), 1 + upright(\"pred_cost\") + upright(\"inputs_cost\") + upright(\"outputs_cost\"))) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\") \\ upright(\"pred_cost\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\") \\ upright(\"inputs_cost\") == upright(\"_t4.a1\") \\ upright(\"_t4\") == upright(\"_f5\") \\ upright(\"outputs_cost\") == upright(\"_t6.a1\") \\ upright(\"_t6\") == upright(\"_f7\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs_cost\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs_cost\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred_cost\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $] \\ upright(\"EcxExtractedVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $] \\ upright(\"EcxExtractedVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]), upright(\"ecx_extracted_body\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"BodyAndCost\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred_extracted\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs_extracted\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs_extracted\") $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ 1 + upright(\"pred_cost\") + upright(\"inputs_cost\") + upright(\"outputs_cost\") $]) $]) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\") \\ upright(\"pred_cost\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\") \\ upright(\"inputs_cost\") == upright(\"_t4.a1\") \\ upright(\"_t4\") == upright(\"_f5\") \\ upright(\"outputs_cost\") == upright(\"_t6.a1\") \\ upright(\"_t6\") == upright(\"_f7\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7667_5_MyTxEggccExtraction_add_rule__r0175__78d8c2fe08347278", + "display_name": "r0175", + "rule_name": "r0175", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 243771, + "line": 7667, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 243771, + "end": 244275 + }, + "pattern_range": { + "start": 243816, + "end": 243827 + }, + "action_range": { + "start": 243829, + "end": 244274 + } + }, + "nodes": [ + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 156771, + "end": 156812 + }, + "inputs": [] + }, + { + "id": "inputs_cost", + "kind": "query", + "dsl_type": "", + "label": "inputs_cost: ", + "range": { + "start": 156817, + "end": 156882 + }, + "inputs": [] + }, + { + "id": "inputs_extracted", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs_extracted: EcxVecOperand", + "range": { + "start": 156887, + "end": 156938 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "lhs: EcxBody", + "range": { + "start": 156943, + "end": 156975 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "outputs: EcxVecVecOperand", + "range": { + "start": 156980, + "end": 157025 + }, + "inputs": [] + }, + { + "id": "outputs_cost", + "kind": "query", + "dsl_type": "", + "label": "outputs_cost: ", + "range": { + "start": 157030, + "end": 157097 + }, + "inputs": [] + }, + { + "id": "outputs_extracted", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "outputs_extracted: EcxVecVecOperand", + "range": { + "start": 157102, + "end": 157157 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 157162, + "end": 157198 + }, + "inputs": [] + }, + { + "id": "pred_cost", + "kind": "query", + "dsl_type": "", + "label": "pred_cost: ", + "range": { + "start": 157203, + "end": 157264 + }, + "inputs": [] + }, + { + "id": "pred_extracted", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred_extracted: EcxOperand", + "range": { + "start": 157269, + "end": 157315 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxGamma", + "label": "_t1: EcxGamma", + "range": { + "start": 157320, + "end": 157372 + }, + "inputs": [ + "pred", + "inputs", + "outputs" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxOperandAndCost", + "label": "_t2: EcxOperandAndCost", + "range": { + "start": 157377, + "end": 157429 + }, + "inputs": [ + "pred_extracted" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxExtractedOperand", + "label": "_f3: EcxExtractedOperand", + "range": { + "start": 157434, + "end": 157478 + }, + "inputs": [ + "pred" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxVecOperandAndCost", + "label": "_t4: EcxVecOperandAndCost", + "range": { + "start": 157483, + "end": 157540 + }, + "inputs": [ + "inputs_extracted" + ] + }, + { + "id": "_f5", + "kind": "query", + "dsl_type": "EcxExtractedVecOperand", + "label": "_f5: EcxExtractedVecOperand", + "range": { + "start": 157545, + "end": 157594 + }, + "inputs": [ + "inputs" + ] + }, + { + "id": "_t6", + "kind": "query", + "dsl_type": "EcxVecVecOperandAndCost", + "label": "_t6: EcxVecVecOperandAndCost", + "range": { + "start": 157599, + "end": 157660 + }, + "inputs": [ + "outputs_extracted" + ] + }, + { + "id": "_f7", + "kind": "query", + "dsl_type": "EcxExtractedVecVecOperand", + "label": "_f7: EcxExtractedVecVecOperand", + "range": { + "start": 157665, + "end": 157718 + }, + "inputs": [ + "outputs" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "outputs", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "pred_extracted", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "inputs_extracted", + "kind": "operand", + "index": 0 + }, + { + "from": "_f5", + "to": "inputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t6", + "to": "outputs_extracted", + "kind": "operand", + "index": 0 + }, + { + "from": "_f7", + "to": "outputs", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "inputs", + "inputs_cost", + "inputs_extracted", + "lhs", + "outputs", + "outputs_cost", + "outputs_extracted", + "pred", + "pred_cost", + "pred_extracted", + "_t1", + "_t2", + "_f3", + "_t4", + "_f5", + "_t6", + "_f7" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 158392, + "end": 158394 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "pred_cost.handle().eq(&_t2.handle_a1())", + "semantic_text": "pred_cost == _t2.a1", + "referenced_vars": [ + "_t2", + "pred_cost" + ], + "range": { + "start": 158408, + "end": 158410 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "_t2.handle().eq(&_f3.handle())", + "semantic_text": "_t2 == _f3", + "referenced_vars": [ + "_f3", + "_t2" + ], + "range": { + "start": 158424, + "end": 158426 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "inputs_cost.handle().eq(&_t4.handle_a1())", + "semantic_text": "inputs_cost == _t4.a1", + "referenced_vars": [ + "_t4", + "inputs_cost" + ], + "range": { + "start": 158440, + "end": 158442 + } + }, + { + "id": "constraint_4", + "source_text": "c4", + "resolved_text": "_t4.handle().eq(&_f5.handle())", + "semantic_text": "_t4 == _f5", + "referenced_vars": [ + "_f5", + "_t4" + ], + "range": { + "start": 158456, + "end": 158458 + } + }, + { + "id": "constraint_5", + "source_text": "c5", + "resolved_text": "outputs_cost.handle().eq(&_t6.handle_a1())", + "semantic_text": "outputs_cost == _t6.a1", + "referenced_vars": [ + "_t6", + "outputs_cost" + ], + "range": { + "start": 158472, + "end": 158474 + } + }, + { + "id": "constraint_6", + "source_text": "c6", + "resolved_text": "_t6.handle().eq(&_f7.handle())", + "semantic_text": "_t6 == _f7", + "referenced_vars": [ + "_f7", + "_t6" + ], + "range": { + "start": 158488, + "end": 158490 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@243859:243991", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_gamma(\n pat.pred_extracted,\n pat.inputs_extracted,\n pat.outputs_extracted,\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "inputs_extracted", + "outputs_extracted", + "pred_extracted" + ], + "referenced_action_vars": [], + "range": { + "start": 243859, + "end": 243991 + } + }, + { + "id": "effect_1", + "effect_id": "effect@244010:244218", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_body_and_cost(\n t2,\n (1_i64\n + (ctx.devalue(pat.pred_cost)\n + (ctx.devalue(pat.inputs_cost) + ctx.devalue(pat.outputs_cost)))),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "inputs_cost", + "outputs_cost", + "pred_cost" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 244010, + "end": 244218 + } + }, + { + "id": "effect_2", + "effect_id": "effect@244228:244267", + "bound_var": null, + "source_text": "ctx.set_ecx_extracted_body(pat.lhs, t1)", + "semantic_text": "ecx_extracted_body(pat.lhs) = t1", + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 244228, + "end": 244267 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0175", + "premises": [ + { + "target_id": "inputs_cost", + "label": "inputs_cost: ", + "plain_source": "upright(\"inputs_cost\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs_cost\") $]" + }, + { + "target_id": "outputs_cost", + "label": "outputs_cost: ", + "plain_source": "upright(\"outputs_cost\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs_cost\") $]" + }, + { + "target_id": "pred_cost", + "label": "pred_cost: ", + "plain_source": "upright(\"pred_cost\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred_cost\") $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxGamma", + "plain_source": "upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxOperandAndCost", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxExtractedOperand", + "plain_source": "upright(\"EcxExtractedOperand\")(upright(\"pred\"))", + "colored_source": "upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxVecOperandAndCost", + "plain_source": "upright(\"_t4\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $]" + }, + { + "target_id": "_f5", + "label": "_f5: EcxExtractedVecOperand", + "plain_source": "upright(\"EcxExtractedVecOperand\")(upright(\"inputs\"))", + "colored_source": "upright(\"EcxExtractedVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $])" + }, + { + "target_id": "_t6", + "label": "_t6: EcxVecVecOperandAndCost", + "plain_source": "upright(\"_t6\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]" + }, + { + "target_id": "_f7", + "label": "_f7: EcxExtractedVecVecOperand", + "plain_source": "upright(\"EcxExtractedVecVecOperand\")(upright(\"outputs\"))", + "colored_source": "upright(\"EcxExtractedVecVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $])" + } + ], + "side_conditions": [ + "upright(\"lhs\") == upright(\"_t1\")", + "upright(\"pred_cost\") == upright(\"_t2.a1\")", + "upright(\"_t2\") == upright(\"_f3\")", + "upright(\"inputs_cost\") == upright(\"_t4.a1\")", + "upright(\"_t4\") == upright(\"_f5\")", + "upright(\"outputs_cost\") == upright(\"_t6.a1\")", + "upright(\"_t6\") == upright(\"_f7\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_2", + "entry": { + "target_id": "effect:effect_2", + "label": "effect_2", + "plain_source": "upright(\"ecx_extracted_body\")(upright(\"lhs\")) = upright(\"BodyAndCost\")((upright(\"Gamma\")(upright(\"pred_extracted\"), upright(\"inputs_extracted\"), upright(\"outputs_extracted\"))), 1 + upright(\"pred_cost\") + upright(\"inputs_cost\") + upright(\"outputs_cost\"))", + "colored_source": "upright(\"ecx_extracted_body\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"BodyAndCost\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred_extracted\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs_extracted\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs_extracted\") $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ 1 + upright(\"pred_cost\") + upright(\"inputs_cost\") + upright(\"outputs_cost\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"inputs_cost\") \\ upright(\"outputs_cost\") \\ upright(\"pred_cost\") \\ upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\")) \\ upright(\"_t2\") \\ upright(\"EcxExtractedOperand\")(upright(\"pred\")) \\ upright(\"_t4\") \\ upright(\"EcxExtractedVecOperand\")(upright(\"inputs\")) \\ upright(\"_t6\") \\ upright(\"EcxExtractedVecVecOperand\")(upright(\"outputs\")), upright(\"ecx_extracted_body\")(upright(\"lhs\")) = upright(\"BodyAndCost\")((upright(\"Gamma\")(upright(\"pred_extracted\"), upright(\"inputs_extracted\"), upright(\"outputs_extracted\"))), 1 + upright(\"pred_cost\") + upright(\"inputs_cost\") + upright(\"outputs_cost\"))) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\") \\ upright(\"pred_cost\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\") \\ upright(\"inputs_cost\") == upright(\"_t4.a1\") \\ upright(\"_t4\") == upright(\"_f5\") \\ upright(\"outputs_cost\") == upright(\"_t6.a1\") \\ upright(\"_t6\") == upright(\"_f7\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs_cost\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs_cost\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred_cost\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $] \\ upright(\"EcxExtractedVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $] \\ upright(\"EcxExtractedVecVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]), upright(\"ecx_extracted_body\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"BodyAndCost\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred_extracted\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs_extracted\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs_extracted\") $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ 1 + upright(\"pred_cost\") + upright(\"inputs_cost\") + upright(\"outputs_cost\") $]) $]) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\") \\ upright(\"pred_cost\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\") \\ upright(\"inputs_cost\") == upright(\"_t4.a1\") \\ upright(\"_t4\") == upright(\"_f5\") \\ upright(\"outputs_cost\") == upright(\"_t6.a1\") \\ upright(\"_t6\") == upright(\"_f7\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7681_5_MyTxEggccExtraction_add_rule__r0176__1773d154f00921f9", + "display_name": "r0176", + "rule_name": "r0176", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 244281, + "line": 7681, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 244281, + "end": 244577 + }, + "pattern_range": { + "start": 244326, + "end": 244337 + }, + "action_range": { + "start": 244339, + "end": 244576 + } + }, + "nodes": [ + { + "id": "body", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "body: EcxBody", + "range": { + "start": 158781, + "end": 158814 + }, + "inputs": [] + }, + { + "id": "body_cost", + "kind": "query", + "dsl_type": "", + "label": "body_cost: ", + "range": { + "start": 158819, + "end": 158880 + }, + "inputs": [] + }, + { + "id": "body_extracted", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "body_extracted: EcxBody", + "range": { + "start": 158885, + "end": 158928 + }, + "inputs": [] + }, + { + "id": "index", + "kind": "query", + "dsl_type": "", + "label": "index: ", + "range": { + "start": 158933, + "end": 158986 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "lhs: EcxOperand", + "range": { + "start": 158991, + "end": 159026 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxProject", + "label": "_t1: EcxProject", + "range": { + "start": 159031, + "end": 159066 + }, + "inputs": [ + "body" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxBodyAndCost", + "label": "_t2: EcxBodyAndCost", + "range": { + "start": 159071, + "end": 159120 + }, + "inputs": [ + "body_extracted" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxExtractedBody", + "label": "_f3: EcxExtractedBody", + "range": { + "start": 159125, + "end": 159166 + }, + "inputs": [ + "body" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "body", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "body_extracted", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "body", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "body", + "body_cost", + "body_extracted", + "index", + "lhs", + "_t1", + "_t2", + "_f3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "index.handle().eq(&_t1.handle_a0())", + "semantic_text": "index == _t1.a0", + "referenced_vars": [ + "_t1", + "index" + ], + "range": { + "start": 159454, + "end": 159456 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 159474, + "end": 159476 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "body_cost.handle().eq(&_t2.handle_a1())", + "semantic_text": "body_cost == _t2.a1", + "referenced_vars": [ + "_t2", + "body_cost" + ], + "range": { + "start": 159494, + "end": 159496 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "_t2.handle().eq(&_f3.handle())", + "semantic_text": "_t2 == _f3", + "referenced_vars": [ + "_f3", + "_t2" + ], + "range": { + "start": 159514, + "end": 159516 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@244369:244435", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_project(ctx.devalue(pat.index), pat.body_extracted)", + "semantic_text": null, + "referenced_pat_vars": [ + "body_extracted", + "index" + ], + "referenced_action_vars": [], + "range": { + "start": 244369, + "end": 244435 + } + }, + { + "id": "effect_1", + "effect_id": "effect@244454:244517", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_operand_and_cost(t2, ctx.devalue(pat.body_cost))", + "semantic_text": null, + "referenced_pat_vars": [ + "body_cost" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 244454, + "end": 244517 + } + }, + { + "id": "effect_2", + "effect_id": "effect@244527:244569", + "bound_var": null, + "source_text": "ctx.set_ecx_extracted_operand(pat.lhs, t1)", + "semantic_text": "ecx_extracted_operand(pat.lhs) = t1", + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 244527, + "end": 244569 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0176", + "premises": [ + { + "target_id": "body_cost", + "label": "body_cost: ", + "plain_source": "upright(\"body_cost\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body_cost\") $]" + }, + { + "target_id": "index", + "label": "index: ", + "plain_source": "upright(\"index\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxProject", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxBodyAndCost", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxExtractedBody", + "plain_source": "upright(\"EcxExtractedBody\")(upright(\"body\"))", + "colored_source": "upright(\"EcxExtractedBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $])" + } + ], + "side_conditions": [ + "upright(\"index\") == upright(\"_t1.a0\")", + "upright(\"lhs\") == upright(\"_t1\")", + "upright(\"body_cost\") == upright(\"_t2.a1\")", + "upright(\"_t2\") == upright(\"_f3\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_2", + "entry": { + "target_id": "effect:effect_2", + "label": "effect_2", + "plain_source": "upright(\"ecx_extracted_operand\")(upright(\"lhs\")) = upright(\"OperandAndCost\")((upright(\"Project\")(upright(\"index\"), upright(\"body_extracted\"))), upright(\"body_cost\"))", + "colored_source": "upright(\"ecx_extracted_operand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandAndCost\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Project\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body_extracted\") $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body_cost\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"body_cost\") \\ upright(\"index\") \\ upright(\"_t1\") \\ upright(\"_t2\") \\ upright(\"EcxExtractedBody\")(upright(\"body\")), upright(\"ecx_extracted_operand\")(upright(\"lhs\")) = upright(\"OperandAndCost\")((upright(\"Project\")(upright(\"index\"), upright(\"body_extracted\"))), upright(\"body_cost\"))) quad upright(\"if\") quad upright(\"index\") == upright(\"_t1.a0\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"body_cost\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body_cost\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ upright(\"EcxExtractedBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $]), upright(\"ecx_extracted_operand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandAndCost\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Project\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body_extracted\") $]) $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body_cost\") $]) $]) quad upright(\"if\") quad upright(\"index\") == upright(\"_t1.a0\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"body_cost\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7686_5_MyTxEggccExtraction_add_rule__r0177__2bdb4d7efc147eef", + "display_name": "r0177", + "rule_name": "r0177", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 244583, + "line": 7686, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 244583, + "end": 244727 + }, + "pattern_range": { + "start": 244628, + "end": 244639 + }, + "action_range": { + "start": 244641, + "end": 244726 + } + }, + "nodes": [ + { + "id": "index", + "kind": "query", + "dsl_type": "", + "label": "index: ", + "range": { + "start": 159940, + "end": 159993 + }, + "inputs": [] + }, + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 159998, + "end": 160039 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "lhs: EcxOperand", + "range": { + "start": 160044, + "end": 160079 + }, + "inputs": [] + }, + { + "id": "kw_loop", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "kw_loop: EcxBody", + "range": { + "start": 160084, + "end": 160120 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "outputs: EcxVecOperand", + "range": { + "start": 160125, + "end": 160167 + }, + "inputs": [] + }, + { + "id": "passedthrough", + "kind": "query_leaf", + "dsl_type": "EcxTermAndCost", + "label": "passedthrough: EcxTermAndCost", + "range": { + "start": 160172, + "end": 160221 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 160226, + "end": 160262 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxProject", + "label": "_t1: EcxProject", + "range": { + "start": 160267, + "end": 160305 + }, + "inputs": [ + "kw_loop" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxTheta", + "label": "_t2: EcxTheta", + "range": { + "start": 160310, + "end": 160362 + }, + "inputs": [ + "pred", + "inputs", + "outputs" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxVecOperand_get", + "label": "_t3: EcxVecOperand_get", + "range": { + "start": 160367, + "end": 160412 + }, + "inputs": [ + "outputs" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxArg", + "label": "_t4: EcxArg", + "range": { + "start": 160417, + "end": 160443 + }, + "inputs": [] + }, + { + "id": "_t6", + "kind": "query", + "dsl_type": "EcxVecOperand_get", + "label": "_t6: EcxVecOperand_get", + "range": { + "start": 160448, + "end": 160492 + }, + "inputs": [ + "inputs" + ] + }, + { + "id": "_f5", + "kind": "query", + "dsl_type": "EcxExtractedOperand", + "label": "_f5: EcxExtractedOperand", + "range": { + "start": 160497, + "end": 160540 + }, + "inputs": [ + "_t6" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "kw_loop", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "outputs", + "kind": "operand", + "index": 2 + }, + { + "from": "_t3", + "to": "outputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t6", + "to": "inputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_f5", + "to": "_t6", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "index", + "inputs", + "lhs", + "kw_loop", + "outputs", + "passedthrough", + "pred", + "_t1", + "_t2", + "_t3", + "_t4", + "_f5", + "_t6" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "index.handle().eq(&_t1.handle_a0())", + "semantic_text": "index == _t1.a0", + "referenced_vars": [ + "_t1", + "index" + ], + "range": { + "start": 161164, + "end": 161166 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 161180, + "end": 161182 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "kw_loop.handle().eq(&_t2.handle())", + "semantic_text": "kw_loop == _t2", + "referenced_vars": [ + "_t2", + "kw_loop" + ], + "range": { + "start": 161196, + "end": 161198 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "index.handle().eq(&_t3.handle_a1())", + "semantic_text": "index == _t3.a1", + "referenced_vars": [ + "_t3", + "index" + ], + "range": { + "start": 161212, + "end": 161214 + } + }, + { + "id": "constraint_4", + "source_text": "c4", + "resolved_text": "index.handle().eq(&_t4.handle_a0())", + "semantic_text": "index == _t4.a0", + "referenced_vars": [ + "_t4", + "index" + ], + "range": { + "start": 161228, + "end": 161230 + } + }, + { + "id": "constraint_5", + "source_text": "c5", + "resolved_text": "_t3.handle().eq(&_t4.handle())", + "semantic_text": "_t3 == _t4", + "referenced_vars": [ + "_t3", + "_t4" + ], + "range": { + "start": 161244, + "end": 161246 + } + }, + { + "id": "constraint_6", + "source_text": "c6", + "resolved_text": "index.handle().eq(&_t6.handle_a1())", + "semantic_text": "index == _t6.a1", + "referenced_vars": [ + "_t6", + "index" + ], + "range": { + "start": 161260, + "end": 161262 + } + }, + { + "id": "constraint_7", + "source_text": "c7", + "resolved_text": "passedthrough.handle().eq(&_f5.handle())", + "semantic_text": "passedthrough == _f5", + "referenced_vars": [ + "_f5", + "passedthrough" + ], + "range": { + "start": 161276, + "end": 161278 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@244662:244719", + "bound_var": null, + "source_text": "ctx.set_ecx_extracted_operand(pat.lhs, pat.passedthrough)", + "semantic_text": "ecx_extracted_operand(pat.lhs) = pat.passedthrough", + "referenced_pat_vars": [ + "lhs", + "passedthrough" + ], + "referenced_action_vars": [], + "range": { + "start": 244662, + "end": 244719 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0177", + "premises": [ + { + "target_id": "index", + "label": "index: ", + "plain_source": "upright(\"index\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxProject", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxTheta", + "plain_source": "upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxVecOperand_get", + "plain_source": "upright(\"_t3\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]" + }, + { + "target_id": "_t4", + "label": "_t4: EcxArg", + "plain_source": "upright(\"_t4\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $]" + }, + { + "target_id": "_f5", + "label": "_f5: EcxExtractedOperand", + "plain_source": "upright(\"EcxExtractedOperand\")(upright(\"_t6\"))", + "colored_source": "upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $])" + }, + { + "target_id": "_t6", + "label": "_t6: EcxVecOperand_get", + "plain_source": "upright(\"_t6\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]" + } + ], + "side_conditions": [ + "upright(\"index\") == upright(\"_t1.a0\")", + "upright(\"lhs\") == upright(\"_t1\")", + "upright(\"kw_loop\") == upright(\"_t2\")", + "upright(\"index\") == upright(\"_t3.a1\")", + "upright(\"index\") == upright(\"_t4.a0\")", + "upright(\"_t3\") == upright(\"_t4\")", + "upright(\"index\") == upright(\"_t6.a1\")", + "upright(\"passedthrough\") == upright(\"_f5\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "effect_0", + "plain_source": "upright(\"ecx_extracted_operand\")(upright(\"lhs\")) = upright(\"passedthrough\")", + "colored_source": "upright(\"ecx_extracted_operand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"passedthrough\") $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"index\") \\ upright(\"_t1\") \\ upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\")) \\ upright(\"_t3\") \\ upright(\"_t4\") \\ upright(\"EcxExtractedOperand\")(upright(\"_t6\")) \\ upright(\"_t6\"), upright(\"ecx_extracted_operand\")(upright(\"lhs\")) = upright(\"passedthrough\")) quad upright(\"if\") quad upright(\"index\") == upright(\"_t1.a0\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"kw_loop\") == upright(\"_t2\") \\ upright(\"index\") == upright(\"_t3.a1\") \\ upright(\"index\") == upright(\"_t4.a0\") \\ upright(\"_t3\") == upright(\"_t4\") \\ upright(\"index\") == upright(\"_t6.a1\") \\ upright(\"passedthrough\") == upright(\"_f5\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $] \\ upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $], upright(\"ecx_extracted_operand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"passedthrough\") $]) quad upright(\"if\") quad upright(\"index\") == upright(\"_t1.a0\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"kw_loop\") == upright(\"_t2\") \\ upright(\"index\") == upright(\"_t3.a1\") \\ upright(\"index\") == upright(\"_t4.a0\") \\ upright(\"_t3\") == upright(\"_t4\") \\ upright(\"index\") == upright(\"_t6.a1\") \\ upright(\"passedthrough\") == upright(\"_f5\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7689_5_MyTxEggccExtraction_add_rule__r0178__f4f507ba4acd3f9f", + "display_name": "r0178", + "rule_name": "r0178", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 244733, + "line": 7689, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 244733, + "end": 244877 + }, + "pattern_range": { + "start": 244778, + "end": 244789 + }, + "action_range": { + "start": 244791, + "end": 244876 + } + }, + "nodes": [ + { + "id": "index", + "kind": "query", + "dsl_type": "", + "label": "index: ", + "range": { + "start": 161963, + "end": 162016 + }, + "inputs": [] + }, + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 162021, + "end": 162062 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "lhs: EcxOperand", + "range": { + "start": 162067, + "end": 162102 + }, + "inputs": [] + }, + { + "id": "kw_loop", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "kw_loop: EcxBody", + "range": { + "start": 162107, + "end": 162143 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "outputs: EcxVecVecOperand", + "range": { + "start": 162148, + "end": 162193 + }, + "inputs": [] + }, + { + "id": "outputs_inner", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperandBase", + "label": "outputs_inner: EcxVecVecOperandBase", + "range": { + "start": 162198, + "end": 162253 + }, + "inputs": [] + }, + { + "id": "outputs0", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "outputs0: EcxVecOperand", + "range": { + "start": 162258, + "end": 162301 + }, + "inputs": [] + }, + { + "id": "outputs1", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "outputs1: EcxVecOperand", + "range": { + "start": 162306, + "end": 162349 + }, + "inputs": [] + }, + { + "id": "passedthrough", + "kind": "query_leaf", + "dsl_type": "EcxTermAndCost", + "label": "passedthrough: EcxTermAndCost", + "range": { + "start": 162354, + "end": 162403 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 162408, + "end": 162444 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxProject", + "label": "_t1: EcxProject", + "range": { + "start": 162449, + "end": 162487 + }, + "inputs": [ + "kw_loop" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxGamma", + "label": "_t2: EcxGamma", + "range": { + "start": 162492, + "end": 162544 + }, + "inputs": [ + "pred", + "inputs", + "outputs" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t3: EcxVVO", + "range": { + "start": 162549, + "end": 162589 + }, + "inputs": [ + "outputs_inner" + ] + }, + { + "id": "_t5", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t5: EcxVVO", + "range": { + "start": 162594, + "end": 162634 + }, + "inputs": [ + "outputs_inner" + ] + }, + { + "id": "_f4", + "kind": "query", + "dsl_type": "EcxVecVecOperand_length", + "label": "_f4: EcxVecVecOperand_length", + "range": { + "start": 162639, + "end": 162686 + }, + "inputs": [ + "_t5" + ] + }, + { + "id": "_t6", + "kind": "query", + "dsl_type": "EcxVecVecOperand_get", + "label": "_t6: EcxVecVecOperand_get", + "range": { + "start": 162691, + "end": 162739 + }, + "inputs": [ + "outputs" + ] + }, + { + "id": "_t7", + "kind": "query", + "dsl_type": "EcxVecVecOperand_get", + "label": "_t7: EcxVecVecOperand_get", + "range": { + "start": 162744, + "end": 162792 + }, + "inputs": [ + "outputs" + ] + }, + { + "id": "_t8", + "kind": "query", + "dsl_type": "EcxVecOperand_get", + "label": "_t8: EcxVecOperand_get", + "range": { + "start": 162797, + "end": 162843 + }, + "inputs": [ + "outputs0" + ] + }, + { + "id": "_t9", + "kind": "query", + "dsl_type": "EcxArg", + "label": "_t9: EcxArg", + "range": { + "start": 162848, + "end": 162874 + }, + "inputs": [] + }, + { + "id": "_t10", + "kind": "query", + "dsl_type": "EcxVecOperand_get", + "label": "_t10: EcxVecOperand_get", + "range": { + "start": 162879, + "end": 162926 + }, + "inputs": [ + "outputs1" + ] + }, + { + "id": "_t11", + "kind": "query", + "dsl_type": "EcxArg", + "label": "_t11: EcxArg", + "range": { + "start": 162931, + "end": 162958 + }, + "inputs": [] + }, + { + "id": "_t13", + "kind": "query", + "dsl_type": "EcxVecOperand_get", + "label": "_t13: EcxVecOperand_get", + "range": { + "start": 162963, + "end": 163008 + }, + "inputs": [ + "inputs" + ] + }, + { + "id": "_f12", + "kind": "query", + "dsl_type": "EcxExtractedOperand", + "label": "_f12: EcxExtractedOperand", + "range": { + "start": 163013, + "end": 163058 + }, + "inputs": [ + "_t13" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "kw_loop", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "outputs", + "kind": "operand", + "index": 2 + }, + { + "from": "_t3", + "to": "outputs_inner", + "kind": "operand", + "index": 0 + }, + { + "from": "_t5", + "to": "outputs_inner", + "kind": "operand", + "index": 0 + }, + { + "from": "_f4", + "to": "_t5", + "kind": "operand", + "index": 0 + }, + { + "from": "_t6", + "to": "outputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t7", + "to": "outputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t8", + "to": "outputs0", + "kind": "operand", + "index": 0 + }, + { + "from": "_t10", + "to": "outputs1", + "kind": "operand", + "index": 0 + }, + { + "from": "_t13", + "to": "inputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_f12", + "to": "_t13", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "index", + "inputs", + "lhs", + "kw_loop", + "outputs", + "outputs_inner", + "outputs0", + "outputs1", + "passedthrough", + "pred", + "_t1", + "_t2", + "_t3", + "_f4", + "_t5", + "_t6", + "_t7", + "_t8", + "_t9", + "_t10", + "_t11", + "_f12", + "_t13" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "index.handle().eq(&_t1.handle_a0())", + "semantic_text": "index == _t1.a0", + "referenced_vars": [ + "_t1", + "index" + ], + "range": { + "start": 164284, + "end": 164286 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 164300, + "end": 164302 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "kw_loop.handle().eq(&_t2.handle())", + "semantic_text": "kw_loop == _t2", + "referenced_vars": [ + "_t2", + "kw_loop" + ], + "range": { + "start": 164316, + "end": 164318 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "outputs.handle().eq(&_t3.handle())", + "semantic_text": "outputs == _t3", + "referenced_vars": [ + "_t3", + "outputs" + ], + "range": { + "start": 164332, + "end": 164334 + } + }, + { + "id": "constraint_4", + "source_text": "c4", + "resolved_text": "(&(2_i64)).as_handle().eq(&_f4.handle())", + "semantic_text": "2 == _f4", + "referenced_vars": [ + "_f4" + ], + "range": { + "start": 164348, + "end": 164350 + } + }, + { + "id": "constraint_5", + "source_text": "c5", + "resolved_text": "_t6.handle_a1().eq(&(0_i64))", + "semantic_text": "_t6.a1 == 0", + "referenced_vars": [ + "_t6" + ], + "range": { + "start": 164364, + "end": 164366 + } + }, + { + "id": "constraint_6", + "source_text": "c6", + "resolved_text": "outputs0.handle().eq(&_t6.handle())", + "semantic_text": "outputs0 == _t6", + "referenced_vars": [ + "_t6", + "outputs0" + ], + "range": { + "start": 164380, + "end": 164382 + } + }, + { + "id": "constraint_7", + "source_text": "c7", + "resolved_text": "_t7.handle_a1().eq(&(1_i64))", + "semantic_text": "_t7.a1 == 1", + "referenced_vars": [ + "_t7" + ], + "range": { + "start": 164396, + "end": 164398 + } + }, + { + "id": "constraint_8", + "source_text": "c8", + "resolved_text": "outputs1.handle().eq(&_t7.handle())", + "semantic_text": "outputs1 == _t7", + "referenced_vars": [ + "_t7", + "outputs1" + ], + "range": { + "start": 164412, + "end": 164414 + } + }, + { + "id": "constraint_9", + "source_text": "c9", + "resolved_text": "index.handle().eq(&_t8.handle_a1())", + "semantic_text": "index == _t8.a1", + "referenced_vars": [ + "_t8", + "index" + ], + "range": { + "start": 164428, + "end": 164430 + } + }, + { + "id": "constraint_10", + "source_text": "c10", + "resolved_text": "index.handle().eq(&_t9.handle_a0())", + "semantic_text": "index == _t9.a0", + "referenced_vars": [ + "_t9", + "index" + ], + "range": { + "start": 164444, + "end": 164447 + } + }, + { + "id": "constraint_11", + "source_text": "c11", + "resolved_text": "_t8.handle().eq(&_t9.handle())", + "semantic_text": "_t8 == _t9", + "referenced_vars": [ + "_t8", + "_t9" + ], + "range": { + "start": 164461, + "end": 164464 + } + }, + { + "id": "constraint_12", + "source_text": "c12", + "resolved_text": "index.handle().eq(&_t10.handle_a1())", + "semantic_text": "index == _t10.a1", + "referenced_vars": [ + "_t10", + "index" + ], + "range": { + "start": 164478, + "end": 164481 + } + }, + { + "id": "constraint_13", + "source_text": "c13", + "resolved_text": "index.handle().eq(&_t11.handle_a0())", + "semantic_text": "index == _t11.a0", + "referenced_vars": [ + "_t11", + "index" + ], + "range": { + "start": 164495, + "end": 164498 + } + }, + { + "id": "constraint_14", + "source_text": "c14", + "resolved_text": "_t10.handle().eq(&_t11.handle())", + "semantic_text": "_t10 == _t11", + "referenced_vars": [ + "_t10", + "_t11" + ], + "range": { + "start": 164512, + "end": 164515 + } + }, + { + "id": "constraint_15", + "source_text": "c15", + "resolved_text": "index.handle().eq(&_t13.handle_a1())", + "semantic_text": "index == _t13.a1", + "referenced_vars": [ + "_t13", + "index" + ], + "range": { + "start": 164529, + "end": 164532 + } + }, + { + "id": "constraint_16", + "source_text": "c16", + "resolved_text": "passedthrough.handle().eq(&_f12.handle())", + "semantic_text": "passedthrough == _f12", + "referenced_vars": [ + "_f12", + "passedthrough" + ], + "range": { + "start": 164546, + "end": 164549 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@244812:244869", + "bound_var": null, + "source_text": "ctx.set_ecx_extracted_operand(pat.lhs, pat.passedthrough)", + "semantic_text": "ecx_extracted_operand(pat.lhs) = pat.passedthrough", + "referenced_pat_vars": [ + "lhs", + "passedthrough" + ], + "referenced_action_vars": [], + "range": { + "start": 244812, + "end": 244869 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0178", + "premises": [ + { + "target_id": "index", + "label": "index: ", + "plain_source": "upright(\"index\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxProject", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxGamma", + "plain_source": "upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"outputs_inner\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs_inner\") $]) $]" + }, + { + "target_id": "_f4", + "label": "_f4: EcxVecVecOperand_length", + "plain_source": "upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(upright(\"outputs_inner\")))", + "colored_source": "upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs_inner\") $]) $])" + }, + { + "target_id": "_t5", + "label": "_t5: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"outputs_inner\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs_inner\") $]) $]" + }, + { + "target_id": "_t6", + "label": "_t6: EcxVecVecOperand_get", + "plain_source": "upright(\"_t6\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]" + }, + { + "target_id": "_t7", + "label": "_t7: EcxVecVecOperand_get", + "plain_source": "upright(\"_t7\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]" + }, + { + "target_id": "_t8", + "label": "_t8: EcxVecOperand_get", + "plain_source": "upright(\"_t8\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t8\") $]" + }, + { + "target_id": "_t9", + "label": "_t9: EcxArg", + "plain_source": "upright(\"_t9\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t9\") $]" + }, + { + "target_id": "_t10", + "label": "_t10: EcxVecOperand_get", + "plain_source": "upright(\"_t10\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $]" + }, + { + "target_id": "_t11", + "label": "_t11: EcxArg", + "plain_source": "upright(\"_t11\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]" + }, + { + "target_id": "_f12", + "label": "_f12: EcxExtractedOperand", + "plain_source": "upright(\"EcxExtractedOperand\")(upright(\"_t13\"))", + "colored_source": "upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t13\") $])" + }, + { + "target_id": "_t13", + "label": "_t13: EcxVecOperand_get", + "plain_source": "upright(\"_t13\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t13\") $]" + } + ], + "side_conditions": [ + "upright(\"index\") == upright(\"_t1.a0\")", + "upright(\"lhs\") == upright(\"_t1\")", + "upright(\"kw_loop\") == upright(\"_t2\")", + "upright(\"outputs\") == upright(\"_t3\")", + "2 == upright(\"_f4\")", + "upright(\"_t6.a1\") == 0", + "upright(\"outputs0\") == upright(\"_t6\")", + "upright(\"_t7.a1\") == 1", + "upright(\"outputs1\") == upright(\"_t7\")", + "upright(\"index\") == upright(\"_t8.a1\")", + "upright(\"index\") == upright(\"_t9.a0\")", + "upright(\"_t8\") == upright(\"_t9\")", + "upright(\"index\") == upright(\"_t10.a1\")", + "upright(\"index\") == upright(\"_t11.a0\")", + "upright(\"_t10\") == upright(\"_t11\")", + "upright(\"index\") == upright(\"_t13.a1\")", + "upright(\"passedthrough\") == upright(\"_f12\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "effect_0", + "plain_source": "upright(\"ecx_extracted_operand\")(upright(\"lhs\")) = upright(\"passedthrough\")", + "colored_source": "upright(\"ecx_extracted_operand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"passedthrough\") $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"index\") \\ upright(\"_t1\") \\ upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\")) \\ upright(\"VVO\")(upright(\"outputs_inner\")) \\ upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(upright(\"outputs_inner\"))) \\ upright(\"VVO\")(upright(\"outputs_inner\")) \\ upright(\"_t6\") \\ upright(\"_t7\") \\ upright(\"_t8\") \\ upright(\"_t9\") \\ upright(\"_t10\") \\ upright(\"_t11\") \\ upright(\"EcxExtractedOperand\")(upright(\"_t13\")) \\ upright(\"_t13\"), upright(\"ecx_extracted_operand\")(upright(\"lhs\")) = upright(\"passedthrough\")) quad upright(\"if\") quad upright(\"index\") == upright(\"_t1.a0\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"kw_loop\") == upright(\"_t2\") \\ upright(\"outputs\") == upright(\"_t3\") \\ 2 == upright(\"_f4\") \\ upright(\"_t6.a1\") == 0 \\ upright(\"outputs0\") == upright(\"_t6\") \\ upright(\"_t7.a1\") == 1 \\ upright(\"outputs1\") == upright(\"_t7\") \\ upright(\"index\") == upright(\"_t8.a1\") \\ upright(\"index\") == upright(\"_t9.a0\") \\ upright(\"_t8\") == upright(\"_t9\") \\ upright(\"index\") == upright(\"_t10.a1\") \\ upright(\"index\") == upright(\"_t11.a0\") \\ upright(\"_t10\") == upright(\"_t11\") \\ upright(\"index\") == upright(\"_t13.a1\") \\ upright(\"passedthrough\") == upright(\"_f12\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"index\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs_inner\") $]) $] \\ upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs_inner\") $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs_inner\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t8\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t9\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $] \\ upright(\"EcxExtractedOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t13\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t13\") $], upright(\"ecx_extracted_operand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"passedthrough\") $]) quad upright(\"if\") quad upright(\"index\") == upright(\"_t1.a0\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"kw_loop\") == upright(\"_t2\") \\ upright(\"outputs\") == upright(\"_t3\") \\ 2 == upright(\"_f4\") \\ upright(\"_t6.a1\") == 0 \\ upright(\"outputs0\") == upright(\"_t6\") \\ upright(\"_t7.a1\") == 1 \\ upright(\"outputs1\") == upright(\"_t7\") \\ upright(\"index\") == upright(\"_t8.a1\") \\ upright(\"index\") == upright(\"_t9.a0\") \\ upright(\"_t8\") == upright(\"_t9\") \\ upright(\"index\") == upright(\"_t10.a1\") \\ upright(\"index\") == upright(\"_t11.a0\") \\ upright(\"_t10\") == upright(\"_t11\") \\ upright(\"index\") == upright(\"_t13.a1\") \\ upright(\"passedthrough\") == upright(\"_f12\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7692_5_MyTxEggccExtraction_add_rule__r0179__d8038b64d46c8660", + "display_name": "r0179", + "rule_name": "r0179", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 244883, + "line": 7692, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 244883, + "end": 245005 + }, + "pattern_range": { + "start": 244928, + "end": 244939 + }, + "action_range": { + "start": 244941, + "end": 245004 + } + }, + "nodes": [ + { + "id": "cost", + "kind": "query", + "dsl_type": "", + "label": "cost: ", + "range": { + "start": 164869, + "end": 164920 + }, + "inputs": [] + }, + { + "id": "extracted", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "extracted: EcxBody", + "range": { + "start": 164925, + "end": 164963 + }, + "inputs": [] + }, + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 164968, + "end": 165009 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "outputs: EcxVecOperand", + "range": { + "start": 165014, + "end": 165056 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 165061, + "end": 165097 + }, + "inputs": [] + }, + { + "id": "theta", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "theta: EcxBody", + "range": { + "start": 165102, + "end": 165136 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxTheta", + "label": "_t1: EcxTheta", + "range": { + "start": 165141, + "end": 165193 + }, + "inputs": [ + "pred", + "inputs", + "outputs" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxBodyAndCost", + "label": "_t2: EcxBodyAndCost", + "range": { + "start": 165198, + "end": 165242 + }, + "inputs": [ + "extracted" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxExtractedBody", + "label": "_f3: EcxExtractedBody", + "range": { + "start": 165247, + "end": 165289 + }, + "inputs": [ + "theta" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "outputs", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "extracted", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "theta", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "cost", + "extracted", + "inputs", + "outputs", + "pred", + "theta", + "_t1", + "_t2", + "_f3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "theta.handle().eq(&_t1.handle())", + "semantic_text": "theta == _t1", + "referenced_vars": [ + "_t1", + "theta" + ], + "range": { + "start": 165526, + "end": 165528 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "cost.handle().eq(&_t2.handle_a1())", + "semantic_text": "cost == _t2.a1", + "referenced_vars": [ + "_t2", + "cost" + ], + "range": { + "start": 165546, + "end": 165548 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "_t2.handle().eq(&_f3.handle())", + "semantic_text": "_t2 == _f3", + "referenced_vars": [ + "_f3", + "_t2" + ], + "range": { + "start": 165566, + "end": 165568 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@244962:244997", + "bound_var": null, + "source_text": "ctx.union(pat.theta, pat.extracted)", + "semantic_text": null, + "referenced_pat_vars": [ + "extracted", + "theta" + ], + "referenced_action_vars": [], + "range": { + "start": 244962, + "end": 244997 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0179", + "premises": [ + { + "target_id": "cost", + "label": "cost: ", + "plain_source": "upright(\"cost\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"cost\") $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxTheta", + "plain_source": "upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxBodyAndCost", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxExtractedBody", + "plain_source": "upright(\"EcxExtractedBody\")(upright(\"theta\"))", + "colored_source": "upright(\"EcxExtractedBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"theta\") $])" + } + ], + "side_conditions": [ + "upright(\"theta\") == upright(\"_t1\")", + "upright(\"cost\") == upright(\"_t2.a1\")", + "upright(\"_t2\") == upright(\"_f3\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_0", + "from": { + "target_id": "theta", + "label": "theta: EcxBody", + "plain_source": "upright(\"theta\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"theta\") $]" + }, + "to": { + "target_id": "extracted", + "label": "extracted: EcxBody", + "plain_source": "upright(\"extracted\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"extracted\") $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"cost\") \\ upright(\"Theta\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\")) \\ upright(\"_t2\") \\ upright(\"EcxExtractedBody\")(upright(\"theta\")), upright(\"theta\") arrow.r.double upright(\"extracted\")) quad upright(\"if\") quad upright(\"theta\") == upright(\"_t1\") \\ upright(\"cost\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"cost\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ upright(\"EcxExtractedBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"theta\") $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"theta\") $] arrow.r.double #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"extracted\") $]) quad upright(\"if\") quad upright(\"theta\") == upright(\"_t1\") \\ upright(\"cost\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7695_5_MyTxEggccExtraction_add_rule__r0180__b5a6c610d62a980d", + "display_name": "r0180", + "rule_name": "r0180", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 245011, + "line": 7695, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 245011, + "end": 245133 + }, + "pattern_range": { + "start": 245056, + "end": 245067 + }, + "action_range": { + "start": 245069, + "end": 245132 + } + }, + "nodes": [ + { + "id": "cost", + "kind": "query", + "dsl_type": "", + "label": "cost: ", + "range": { + "start": 165891, + "end": 165942 + }, + "inputs": [] + }, + { + "id": "extracted", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "extracted: EcxBody", + "range": { + "start": 165947, + "end": 165985 + }, + "inputs": [] + }, + { + "id": "gamma", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "gamma: EcxBody", + "range": { + "start": 165990, + "end": 166024 + }, + "inputs": [] + }, + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 166029, + "end": 166070 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperand", + "label": "outputs: EcxVecVecOperand", + "range": { + "start": 166075, + "end": 166120 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 166125, + "end": 166161 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxGamma", + "label": "_t1: EcxGamma", + "range": { + "start": 166166, + "end": 166218 + }, + "inputs": [ + "pred", + "inputs", + "outputs" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxBodyAndCost", + "label": "_t2: EcxBodyAndCost", + "range": { + "start": 166223, + "end": 166267 + }, + "inputs": [ + "extracted" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxExtractedBody", + "label": "_f3: EcxExtractedBody", + "range": { + "start": 166272, + "end": 166314 + }, + "inputs": [ + "gamma" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "outputs", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "extracted", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "gamma", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "cost", + "extracted", + "gamma", + "inputs", + "outputs", + "pred", + "_t1", + "_t2", + "_f3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "gamma.handle().eq(&_t1.handle())", + "semantic_text": "gamma == _t1", + "referenced_vars": [ + "_t1", + "gamma" + ], + "range": { + "start": 166551, + "end": 166553 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "cost.handle().eq(&_t2.handle_a1())", + "semantic_text": "cost == _t2.a1", + "referenced_vars": [ + "_t2", + "cost" + ], + "range": { + "start": 166571, + "end": 166573 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "_t2.handle().eq(&_f3.handle())", + "semantic_text": "_t2 == _f3", + "referenced_vars": [ + "_f3", + "_t2" + ], + "range": { + "start": 166591, + "end": 166593 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@245090:245125", + "bound_var": null, + "source_text": "ctx.union(pat.gamma, pat.extracted)", + "semantic_text": null, + "referenced_pat_vars": [ + "extracted", + "gamma" + ], + "referenced_action_vars": [], + "range": { + "start": 245090, + "end": 245125 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0180", + "premises": [ + { + "target_id": "cost", + "label": "cost: ", + "plain_source": "upright(\"cost\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"cost\") $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxGamma", + "plain_source": "upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxBodyAndCost", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxExtractedBody", + "plain_source": "upright(\"EcxExtractedBody\")(upright(\"gamma\"))", + "colored_source": "upright(\"EcxExtractedBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"gamma\") $])" + } + ], + "side_conditions": [ + "upright(\"gamma\") == upright(\"_t1\")", + "upright(\"cost\") == upright(\"_t2.a1\")", + "upright(\"_t2\") == upright(\"_f3\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_0", + "from": { + "target_id": "gamma", + "label": "gamma: EcxBody", + "plain_source": "upright(\"gamma\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"gamma\") $]" + }, + "to": { + "target_id": "extracted", + "label": "extracted: EcxBody", + "plain_source": "upright(\"extracted\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"extracted\") $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"cost\") \\ upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), upright(\"outputs\")) \\ upright(\"_t2\") \\ upright(\"EcxExtractedBody\")(upright(\"gamma\")), upright(\"gamma\") arrow.r.double upright(\"extracted\")) quad upright(\"if\") quad upright(\"gamma\") == upright(\"_t1\") \\ upright(\"cost\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"cost\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ upright(\"EcxExtractedBody\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"gamma\") $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"gamma\") $] arrow.r.double #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"extracted\") $]) quad upright(\"if\") quad upright(\"gamma\") == upright(\"_t1\") \\ upright(\"cost\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7698_5_MyTxEggccExtraction_add_rule__r0181__7319db6dae512529", + "display_name": "r0181", + "rule_name": "r0181", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 245139, + "line": 7698, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 245139, + "end": 245411 + }, + "pattern_range": { + "start": 245184, + "end": 245195 + }, + "action_range": { + "start": 245197, + "end": 245410 + } + }, + "nodes": [ + { + "id": "body", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "body: EcxVecOperand", + "range": { + "start": 166946, + "end": 166985 + }, + "inputs": [] + }, + { + "id": "cost", + "kind": "query", + "dsl_type": "", + "label": "cost: ", + "range": { + "start": 166990, + "end": 167041 + }, + "inputs": [] + }, + { + "id": "extracted", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "extracted: EcxVecOperand", + "range": { + "start": 167046, + "end": 167090 + }, + "inputs": [] + }, + { + "id": "func", + "kind": "query_leaf", + "dsl_type": "EcxFunction", + "label": "func: EcxFunction", + "range": { + "start": 167095, + "end": 167132 + }, + "inputs": [] + }, + { + "id": "intypes", + "kind": "query_leaf", + "dsl_type": "EcxFuncSigs", + "label": "intypes: EcxFuncSigs", + "range": { + "start": 167137, + "end": 167177 + }, + "inputs": [] + }, + { + "id": "name", + "kind": "query", + "dsl_type": "", + "label": "name: ", + "range": { + "start": 167182, + "end": 167236 + }, + "inputs": [] + }, + { + "id": "outtypes", + "kind": "query_leaf", + "dsl_type": "EcxFuncSigs", + "label": "outtypes: EcxFuncSigs", + "range": { + "start": 167241, + "end": 167282 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxFunc", + "label": "_t1: EcxFunc", + "range": { + "start": 167287, + "end": 167340 + }, + "inputs": [ + "intypes", + "outtypes", + "body" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVecOperandAndCost", + "label": "_t2: EcxVecOperandAndCost", + "range": { + "start": 167345, + "end": 167395 + }, + "inputs": [ + "extracted" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxExtractedVecOperand", + "label": "_f3: EcxExtractedVecOperand", + "range": { + "start": 167400, + "end": 167447 + }, + "inputs": [ + "body" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "intypes", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "outtypes", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "body", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "extracted", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "body", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "body", + "cost", + "extracted", + "func", + "intypes", + "name", + "outtypes", + "_t1", + "_t2", + "_f3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "name.handle().eq(&_t1.handle_a0())", + "semantic_text": "name == _t1.a0", + "referenced_vars": [ + "_t1", + "name" + ], + "range": { + "start": 167750, + "end": 167752 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "func.handle().eq(&_t1.handle())", + "semantic_text": "func == _t1", + "referenced_vars": [ + "_t1", + "func" + ], + "range": { + "start": 167766, + "end": 167768 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "cost.handle().eq(&_t2.handle_a1())", + "semantic_text": "cost == _t2.a1", + "referenced_vars": [ + "_t2", + "cost" + ], + "range": { + "start": 167782, + "end": 167784 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "_t2.handle().eq(&_f3.handle())", + "semantic_text": "_t2 == _f3", + "referenced_vars": [ + "_f3", + "_t2" + ], + "range": { + "start": 167798, + "end": 167800 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@245227:245370", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_func(\n ctx.devalue(pat.name),\n pat.intypes,\n pat.outtypes,\n pat.extracted,\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "extracted", + "intypes", + "name", + "outtypes" + ], + "referenced_action_vars": [], + "range": { + "start": 245227, + "end": 245370 + } + }, + { + "id": "effect_1", + "effect_id": "effect@245380:245403", + "bound_var": null, + "source_text": "ctx.union(pat.func, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "func" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 245380, + "end": 245403 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0181", + "premises": [ + { + "target_id": "cost", + "label": "cost: ", + "plain_source": "upright(\"cost\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"cost\") $]" + }, + { + "target_id": "name", + "label": "name: ", + "plain_source": "upright(\"name\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"name\") $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxFunc", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVecOperandAndCost", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxExtractedVecOperand", + "plain_source": "upright(\"EcxExtractedVecOperand\")(upright(\"body\"))", + "colored_source": "upright(\"EcxExtractedVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $])" + } + ], + "side_conditions": [ + "upright(\"name\") == upright(\"_t1.a0\")", + "upright(\"func\") == upright(\"_t1\")", + "upright(\"cost\") == upright(\"_t2.a1\")", + "upright(\"_t2\") == upright(\"_f3\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"Func\")(upright(\"name\"), upright(\"intypes\"), upright(\"outtypes\"), upright(\"extracted\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Func\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"name\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"intypes\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outtypes\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"extracted\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "func", + "label": "func: EcxFunction", + "plain_source": "upright(\"func\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"func\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"Func\")(upright(\"name\"), upright(\"intypes\"), upright(\"outtypes\"), upright(\"extracted\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Func\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"name\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"intypes\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outtypes\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"extracted\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"cost\") \\ upright(\"name\") \\ upright(\"_t1\") \\ upright(\"_t2\") \\ upright(\"EcxExtractedVecOperand\")(upright(\"body\")), upright(\"func\") arrow.r.double upright(\"Func\")(upright(\"name\"), upright(\"intypes\"), upright(\"outtypes\"), upright(\"extracted\"))) quad upright(\"if\") quad upright(\"name\") == upright(\"_t1.a0\") \\ upright(\"func\") == upright(\"_t1\") \\ upright(\"cost\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"cost\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"name\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ upright(\"EcxExtractedVecOperand\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"func\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Func\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"name\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"intypes\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outtypes\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"extracted\") $]) $]) quad upright(\"if\") quad upright(\"name\") == upright(\"_t1.a0\") \\ upright(\"func\") == upright(\"_t1\") \\ upright(\"cost\") == upright(\"_t2.a1\") \\ upright(\"_t2\") == upright(\"_f3\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7707_5_MyTxEggccExtraction_add_rule__r0182__f681ec1d5c6f4aab", + "display_name": "r0182", + "rule_name": "r0182", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 245417, + "line": 7707, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 245417, + "end": 246756 + }, + "pattern_range": { + "start": 245468, + "end": 245479 + }, + "action_range": { + "start": 245481, + "end": 246755 + } + }, + "nodes": [ + { + "id": "A", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "A: EcxVecOperandBase", + "range": { + "start": 168477, + "end": 168517 + }, + "inputs": [] + }, + { + "id": "B", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "B: EcxVecOperandBase", + "range": { + "start": 168522, + "end": 168562 + }, + "inputs": [] + }, + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 168567, + "end": 168600 + }, + "inputs": [] + }, + { + "id": "args", + "kind": "query", + "dsl_type": "", + "label": "args: ", + "range": { + "start": 168605, + "end": 168656 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 168661, + "end": 168694 + }, + "inputs": [] + }, + { + "id": "gamma", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "gamma: EcxBody", + "range": { + "start": 168699, + "end": 168733 + }, + "inputs": [] + }, + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "inputs: EcxVecOperandBase", + "range": { + "start": 168738, + "end": 168783 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperandBase", + "label": "outputs: EcxVecVecOperandBase", + "range": { + "start": 168788, + "end": 168837 + }, + "inputs": [] + }, + { + "id": "rets", + "kind": "query", + "dsl_type": "", + "label": "rets: ", + "range": { + "start": 168842, + "end": 168893 + }, + "inputs": [] + }, + { + "id": "_t5", + "kind": "query", + "dsl_type": "EcxBoolT", + "label": "_t5: EcxBoolT", + "range": { + "start": 168898, + "end": 168926 + }, + "inputs": [] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "Ecxband", + "label": "_t4: Ecxband", + "range": { + "start": 168931, + "end": 168970 + }, + "inputs": [ + "_t5", + "a", + "b" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t3: EcxPureOp", + "range": { + "start": 168975, + "end": 169008 + }, + "inputs": [ + "_t4" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t2: EcxNode", + "range": { + "start": 169013, + "end": 169044 + }, + "inputs": [ + "_t3" + ] + }, + { + "id": "_t6", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t6: EcxVO", + "range": { + "start": 169049, + "end": 169081 + }, + "inputs": [ + "inputs" + ] + }, + { + "id": "_t7", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t7: EcxVVO", + "range": { + "start": 169086, + "end": 169120 + }, + "inputs": [ + "outputs" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxGamma", + "label": "_t1: EcxGamma", + "range": { + "start": 169125, + "end": 169169 + }, + "inputs": [ + "_t2", + "_t6", + "_t7" + ] + }, + { + "id": "_t9", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t9: EcxVVO", + "range": { + "start": 169174, + "end": 169208 + }, + "inputs": [ + "outputs" + ] + }, + { + "id": "_f8", + "kind": "query", + "dsl_type": "EcxVecVecOperand_length", + "label": "_f8: EcxVecVecOperand_length", + "range": { + "start": 169213, + "end": 169260 + }, + "inputs": [ + "_t9" + ] + }, + { + "id": "_t11", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t11: EcxVVO", + "range": { + "start": 169265, + "end": 169300 + }, + "inputs": [ + "outputs" + ] + }, + { + "id": "_t10", + "kind": "query", + "dsl_type": "EcxVecVecOperand_get", + "label": "_t10: EcxVecVecOperand_get", + "range": { + "start": 169305, + "end": 169351 + }, + "inputs": [ + "_t11" + ] + }, + { + "id": "_t12", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t12: EcxVO", + "range": { + "start": 169356, + "end": 169384 + }, + "inputs": [ + "A" + ] + }, + { + "id": "_t14", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t14: EcxVVO", + "range": { + "start": 169389, + "end": 169424 + }, + "inputs": [ + "outputs" + ] + }, + { + "id": "_t13", + "kind": "query", + "dsl_type": "EcxVecVecOperand_get", + "label": "_t13: EcxVecVecOperand_get", + "range": { + "start": 169429, + "end": 169475 + }, + "inputs": [ + "_t14" + ] + }, + { + "id": "_t15", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t15: EcxVO", + "range": { + "start": 169480, + "end": 169508 + }, + "inputs": [ + "B" + ] + }, + { + "id": "_t17", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t17: EcxVO", + "range": { + "start": 169513, + "end": 169546 + }, + "inputs": [ + "inputs" + ] + }, + { + "id": "_f16", + "kind": "query", + "dsl_type": "EcxVecOperand_length", + "label": "_f16: EcxVecOperand_length", + "range": { + "start": 169551, + "end": 169597 + }, + "inputs": [ + "_t17" + ] + }, + { + "id": "_t19", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t19: EcxVO", + "range": { + "start": 169602, + "end": 169630 + }, + "inputs": [ + "B" + ] + }, + { + "id": "_f18", + "kind": "query", + "dsl_type": "EcxVecOperand_length", + "label": "_f18: EcxVecOperand_length", + "range": { + "start": 169635, + "end": 169681 + }, + "inputs": [ + "_t19" + ] + } + ], + "edges": [ + { + "from": "_t4", + "to": "_t5", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "a", + "kind": "operand", + "index": 1 + }, + { + "from": "_t4", + "to": "b", + "kind": "operand", + "index": 2 + }, + { + "from": "_t3", + "to": "_t4", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "_t3", + "kind": "operand", + "index": 0 + }, + { + "from": "_t6", + "to": "inputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t7", + "to": "outputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t6", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "_t7", + "kind": "operand", + "index": 2 + }, + { + "from": "_t9", + "to": "outputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_f8", + "to": "_t9", + "kind": "operand", + "index": 0 + }, + { + "from": "_t11", + "to": "outputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t10", + "to": "_t11", + "kind": "operand", + "index": 0 + }, + { + "from": "_t12", + "to": "A", + "kind": "operand", + "index": 0 + }, + { + "from": "_t14", + "to": "outputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t13", + "to": "_t14", + "kind": "operand", + "index": 0 + }, + { + "from": "_t15", + "to": "B", + "kind": "operand", + "index": 0 + }, + { + "from": "_t17", + "to": "inputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_f16", + "to": "_t17", + "kind": "operand", + "index": 0 + }, + { + "from": "_t19", + "to": "B", + "kind": "operand", + "index": 0 + }, + { + "from": "_f18", + "to": "_t19", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "A", + "B", + "a", + "args", + "b", + "gamma", + "inputs", + "outputs", + "rets", + "_t1", + "_t2", + "_t3", + "_t4", + "_t5", + "_t6", + "_t7", + "_f8", + "_t9", + "_t10", + "_t11", + "_t12", + "_t13", + "_t14", + "_t15", + "_f16", + "_t17", + "_f18", + "_t19" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "gamma.handle().eq(&_t1.handle())", + "semantic_text": "gamma == _t1", + "referenced_vars": [ + "_t1", + "gamma" + ], + "range": { + "start": 170265, + "end": 170267 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "_f8.handle().eq(&(&(2_i64)).as_handle())", + "semantic_text": "_f8 == 2", + "referenced_vars": [ + "_f8" + ], + "range": { + "start": 170281, + "end": 170283 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "_t10.handle_a1().eq(&(1_i64))", + "semantic_text": "_t10.a1 == 1", + "referenced_vars": [ + "_t10" + ], + "range": { + "start": 170297, + "end": 170299 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "_t10.handle().eq(&_t12.handle())", + "semantic_text": "_t10 == _t12", + "referenced_vars": [ + "_t10", + "_t12" + ], + "range": { + "start": 170313, + "end": 170315 + } + }, + { + "id": "constraint_4", + "source_text": "c4", + "resolved_text": "_t13.handle_a1().eq(&(0_i64))", + "semantic_text": "_t13.a1 == 0", + "referenced_vars": [ + "_t13" + ], + "range": { + "start": 170329, + "end": 170331 + } + }, + { + "id": "constraint_5", + "source_text": "c5", + "resolved_text": "_t13.handle().eq(&_t15.handle())", + "semantic_text": "_t13 == _t15", + "referenced_vars": [ + "_t13", + "_t15" + ], + "range": { + "start": 170345, + "end": 170347 + } + }, + { + "id": "constraint_6", + "source_text": "c6", + "resolved_text": "args.handle().eq(&_f16.handle())", + "semantic_text": "args == _f16", + "referenced_vars": [ + "_f16", + "args" + ], + "range": { + "start": 170361, + "end": 170363 + } + }, + { + "id": "constraint_7", + "source_text": "c7", + "resolved_text": "rets.handle().eq(&_f18.handle())", + "semantic_text": "rets == _f18", + "referenced_vars": [ + "_f18", + "rets" + ], + "range": { + "start": 170377, + "end": 170379 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@245511:245552", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_arg(ctx.devalue(pat.args))", + "semantic_text": null, + "referenced_pat_vars": [ + "args" + ], + "referenced_action_vars": [], + "range": { + "start": 245511, + "end": 245552 + } + }, + { + "id": "effect_1", + "effect_id": "effect@245571:245631", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_pass_through_arguments(ctx.devalue(pat.args))", + "semantic_text": null, + "referenced_pat_vars": [ + "args" + ], + "referenced_action_vars": [], + "range": { + "start": 245571, + "end": 245631 + } + }, + { + "id": "effect_2", + "effect_id": "effect@245650:245674", + "bound_var": "t5", + "source_text": "ctx.insert_ecx_vo(pat.B)", + "semantic_text": null, + "referenced_pat_vars": [ + "B" + ], + "referenced_action_vars": [], + "range": { + "start": 245650, + "end": 245674 + } + }, + { + "id": "effect_3", + "effect_id": "effect@245693:245717", + "bound_var": "t6", + "source_text": "ctx.insert_ecx_vo(pat.A)", + "semantic_text": null, + "referenced_pat_vars": [ + "A" + ], + "referenced_action_vars": [], + "range": { + "start": 245693, + "end": 245717 + } + }, + { + "id": "effect_4", + "effect_id": "effect@245736:245950", + "bound_var": "t4", + "source_text": "ctx.insert_ecx_vvo(\n ctx.intern_container::>(\n VecContainer::::from(vec![t5.erase(), t6.erase()]),\n ),\n )", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 245736, + "end": 245950 + } + }, + { + "id": "effect_5", + "effect_id": "effect@245969:246001", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_gamma(t2, t3, t4)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t2", + "t3", + "t4" + ], + "range": { + "start": 245969, + "end": 246001 + } + }, + { + "id": "effect_6", + "effect_id": "effect@246044:246297", + "bound_var": "t8", + "source_text": "ctx.insert_ecx_vo(\n ctx.intern_container::>(vec_push::<\n EcxOperand,\n >(\n &*ctx.devalue(pat.inputs),\n pat.b.erase(),\n )),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "inputs" + ], + "referenced_action_vars": [], + "range": { + "start": 246044, + "end": 246297 + } + }, + { + "id": "effect_7", + "effect_id": "effect@246317:246341", + "bound_var": "t10", + "source_text": "ctx.insert_ecx_vo(pat.B)", + "semantic_text": null, + "referenced_pat_vars": [ + "B" + ], + "referenced_action_vars": [], + "range": { + "start": 246317, + "end": 246341 + } + }, + { + "id": "effect_8", + "effect_id": "effect@246361:246425", + "bound_var": "t11", + "source_text": "ctx.insert_ecx_body_to_vec_operand(ctx.devalue(pat.rets), inner)", + "semantic_text": null, + "referenced_pat_vars": [ + "rets" + ], + "referenced_action_vars": [], + "range": { + "start": 246361, + "end": 246425 + } + }, + { + "id": "effect_9", + "effect_id": "effect@246444:246660", + "bound_var": "t9", + "source_text": "ctx.insert_ecx_vvo(\n ctx.intern_container::>(\n VecContainer::::from(vec![t10.erase(), t11.erase()]),\n ),\n )", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 246444, + "end": 246660 + } + }, + { + "id": "effect_10", + "effect_id": "effect@246679:246714", + "bound_var": "t7", + "source_text": "ctx.insert_ecx_gamma(pat.a, t8, t9)", + "semantic_text": null, + "referenced_pat_vars": [ + "a" + ], + "referenced_action_vars": [ + "t8", + "t9" + ], + "range": { + "start": 246679, + "end": 246714 + } + }, + { + "id": "effect_11", + "effect_id": "effect@246724:246748", + "bound_var": null, + "source_text": "ctx.union(pat.gamma, t7)", + "semantic_text": null, + "referenced_pat_vars": [ + "gamma" + ], + "referenced_action_vars": [ + "t7" + ], + "range": { + "start": 246724, + "end": 246748 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0182", + "premises": [ + { + "target_id": "args", + "label": "args: ", + "plain_source": "upright(\"args\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"args\") $]" + }, + { + "target_id": "rets", + "label": "rets: ", + "plain_source": "upright(\"rets\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rets\") $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxGamma", + "plain_source": "upright(\"Gamma\")((upright(\"Node\")((upright(\"PureOp\")((upright(\"band\")(upright(\"BoolT\"), a, b)))))), (upright(\"VO\")(upright(\"inputs\"))), (upright(\"VVO\")(upright(\"outputs\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"band\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $])) $])) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxNode", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"band\")(upright(\"BoolT\"), a, b)))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"band\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $])) $])) $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxPureOp", + "plain_source": "upright(\"PureOp\")((upright(\"band\")(upright(\"BoolT\"), a, b)))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"band\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $])) $]" + }, + { + "target_id": "_t4", + "label": "_t4: Ecxband", + "plain_source": "upright(\"band\")(upright(\"BoolT\"), a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"band\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + }, + { + "target_id": "_t5", + "label": "_t5: EcxBoolT", + "plain_source": "upright(\"BoolT\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $]" + }, + { + "target_id": "_t6", + "label": "_t6: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"inputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $]" + }, + { + "target_id": "_t7", + "label": "_t7: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "_f8", + "label": "_f8: EcxVecVecOperand_length", + "plain_source": "upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(upright(\"outputs\")))", + "colored_source": "upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])" + }, + { + "target_id": "_t9", + "label": "_t9: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "_t10", + "label": "_t10: EcxVecVecOperand_get", + "plain_source": "upright(\"_t10\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $]" + }, + { + "target_id": "_t11", + "label": "_t11: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "_t12", + "label": "_t12: EcxVO", + "plain_source": "upright(\"VO\")(A)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ A $]) $]" + }, + { + "target_id": "_t13", + "label": "_t13: EcxVecVecOperand_get", + "plain_source": "upright(\"_t13\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t13\") $]" + }, + { + "target_id": "_t14", + "label": "_t14: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "_t15", + "label": "_t15: EcxVO", + "plain_source": "upright(\"VO\")(B)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ B $]) $]" + }, + { + "target_id": "_f16", + "label": "_f16: EcxVecOperand_length", + "plain_source": "upright(\"EcxVecOperand_length\")(upright(\"VO\")(upright(\"inputs\")))", + "colored_source": "upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $])" + }, + { + "target_id": "_t17", + "label": "_t17: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"inputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $]" + }, + { + "target_id": "_f18", + "label": "_f18: EcxVecOperand_length", + "plain_source": "upright(\"EcxVecOperand_length\")(upright(\"VO\")(B))", + "colored_source": "upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ B $]) $])" + }, + { + "target_id": "_t19", + "label": "_t19: EcxVO", + "plain_source": "upright(\"VO\")(B)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ B $]) $]" + } + ], + "side_conditions": [ + "upright(\"gamma\") == upright(\"_t1\")", + "upright(\"_f8\") == 2", + "upright(\"_t10.a1\") == 1", + "upright(\"_t10\") == upright(\"_t12\")", + "upright(\"_t13.a1\") == 0", + "upright(\"_t13\") == upright(\"_t15\")", + "upright(\"args\") == upright(\"_f16\")", + "upright(\"rets\") == upright(\"_f18\")" + ], + "derivations": [ + { + "target_id": "effect:effect_6", + "label": "t8", + "plain_source": "upright(\"EcxVo\")(upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"inputs\"), upright(\"b.erase\")())))", + "colored_source": "upright(\"EcxVo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"inputs\"), upright(\"b.erase\")())) $])" + }, + { + "target_id": "effect:effect_9", + "label": "t9", + "plain_source": "upright(\"EcxVvo\")(upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"from\")(upright(\"vec\")![upright(\"t10.erase\")(), upright(\"t11.erase\")()])))", + "colored_source": "upright(\"EcxVvo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"from\")(upright(\"vec\")![upright(\"t10.erase\")(), upright(\"t11.erase\")()])) $])" + }, + { + "target_id": "effect:effect_10", + "label": "t7", + "plain_source": "upright(\"Gamma\")(a, upright(\"EcxVo\")(upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"inputs\"), upright(\"b.erase\")()))), upright(\"EcxVvo\")(upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"from\")(upright(\"vec\")![upright(\"t10.erase\")(), upright(\"t11.erase\")()]))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], upright(\"EcxVo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"inputs\"), upright(\"b.erase\")())) $]), upright(\"EcxVvo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"from\")(upright(\"vec\")![upright(\"t10.erase\")(), upright(\"t11.erase\")()])) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_11", + "from": { + "target_id": "gamma", + "label": "gamma: EcxBody", + "plain_source": "upright(\"gamma\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"gamma\") $]" + }, + "to": { + "target_id": "effect:effect_10", + "label": "t7", + "plain_source": "upright(\"Gamma\")(a, upright(\"EcxVo\")(upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"inputs\"), upright(\"b.erase\")()))), upright(\"EcxVvo\")(upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"from\")(upright(\"vec\")![upright(\"t10.erase\")(), upright(\"t11.erase\")()]))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], upright(\"EcxVo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"inputs\"), upright(\"b.erase\")())) $]), upright(\"EcxVvo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"from\")(upright(\"vec\")![upright(\"t10.erase\")(), upright(\"t11.erase\")()])) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"args\") \\ upright(\"rets\") \\ upright(\"Gamma\")((upright(\"Node\")((upright(\"PureOp\")((upright(\"band\")(upright(\"BoolT\"), a, b)))))), (upright(\"VO\")(upright(\"inputs\"))), (upright(\"VVO\")(upright(\"outputs\")))) \\ upright(\"Node\")((upright(\"PureOp\")((upright(\"band\")(upright(\"BoolT\"), a, b))))) \\ upright(\"PureOp\")((upright(\"band\")(upright(\"BoolT\"), a, b))) \\ upright(\"band\")(upright(\"BoolT\"), a, b) \\ upright(\"BoolT\") \\ upright(\"VO\")(upright(\"inputs\")) \\ upright(\"VVO\")(upright(\"outputs\")) \\ upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(upright(\"outputs\"))) \\ upright(\"VVO\")(upright(\"outputs\")) \\ upright(\"_t10\") \\ upright(\"VVO\")(upright(\"outputs\")) \\ upright(\"VO\")(A) \\ upright(\"_t13\") \\ upright(\"VVO\")(upright(\"outputs\")) \\ upright(\"VO\")(B) \\ upright(\"EcxVecOperand_length\")(upright(\"VO\")(upright(\"inputs\"))) \\ upright(\"VO\")(upright(\"inputs\")) \\ upright(\"EcxVecOperand_length\")(upright(\"VO\")(B)) \\ upright(\"VO\")(B), upright(\"gamma\") arrow.r.double upright(\"Gamma\")(a, upright(\"EcxVo\")(upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"inputs\"), upright(\"b.erase\")()))), upright(\"EcxVvo\")(upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"from\")(upright(\"vec\")![upright(\"t10.erase\")(), upright(\"t11.erase\")()]))))) quad upright(\"if\") quad upright(\"gamma\") == upright(\"_t1\") \\ upright(\"_f8\") == 2 \\ upright(\"_t10.a1\") == 1 \\ upright(\"_t10\") == upright(\"_t12\") \\ upright(\"_t13.a1\") == 0 \\ upright(\"_t13\") == upright(\"_t15\") \\ upright(\"args\") == upright(\"_f16\") \\ upright(\"rets\") == upright(\"_f18\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"args\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rets\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"band\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $])) $])) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"band\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"band\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"band\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $] \\ upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ A $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t13\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ B $]) $] \\ upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $] \\ upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ B $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ B $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"gamma\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], upright(\"EcxVo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"inputs\"), upright(\"b.erase\")())) $]), upright(\"EcxVvo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"from\")(upright(\"vec\")![upright(\"t10.erase\")(), upright(\"t11.erase\")()])) $])) $]) quad upright(\"if\") quad upright(\"gamma\") == upright(\"_t1\") \\ upright(\"_f8\") == 2 \\ upright(\"_t10.a1\") == 1 \\ upright(\"_t10\") == upright(\"_t12\") \\ upright(\"_t13.a1\") == 0 \\ upright(\"_t13\") == upright(\"_t15\") \\ upright(\"args\") == upright(\"_f16\") \\ upright(\"rets\") == upright(\"_f18\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7737_5_MyTxEggccExtraction_add_rule__r0183__246b5b09c1ea28db", + "display_name": "r0183", + "rule_name": "r0183", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 246762, + "line": 7737, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 246762, + "end": 248101 + }, + "pattern_range": { + "start": 246813, + "end": 246824 + }, + "action_range": { + "start": 246826, + "end": 248100 + } + }, + "nodes": [ + { + "id": "A", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "A: EcxVecOperandBase", + "range": { + "start": 171055, + "end": 171095 + }, + "inputs": [] + }, + { + "id": "B", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "B: EcxVecOperandBase", + "range": { + "start": 171100, + "end": 171140 + }, + "inputs": [] + }, + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 171145, + "end": 171178 + }, + "inputs": [] + }, + { + "id": "args", + "kind": "query", + "dsl_type": "", + "label": "args: ", + "range": { + "start": 171183, + "end": 171234 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 171239, + "end": 171272 + }, + "inputs": [] + }, + { + "id": "gamma", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "gamma: EcxBody", + "range": { + "start": 171277, + "end": 171311 + }, + "inputs": [] + }, + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "inputs: EcxVecOperandBase", + "range": { + "start": 171316, + "end": 171361 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperandBase", + "label": "outputs: EcxVecVecOperandBase", + "range": { + "start": 171366, + "end": 171415 + }, + "inputs": [] + }, + { + "id": "rets", + "kind": "query", + "dsl_type": "", + "label": "rets: ", + "range": { + "start": 171420, + "end": 171471 + }, + "inputs": [] + }, + { + "id": "_t5", + "kind": "query", + "dsl_type": "EcxBoolT", + "label": "_t5: EcxBoolT", + "range": { + "start": 171476, + "end": 171504 + }, + "inputs": [] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "Ecxbor", + "label": "_t4: Ecxbor", + "range": { + "start": 171509, + "end": 171547 + }, + "inputs": [ + "_t5", + "a", + "b" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t3: EcxPureOp", + "range": { + "start": 171552, + "end": 171585 + }, + "inputs": [ + "_t4" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t2: EcxNode", + "range": { + "start": 171590, + "end": 171621 + }, + "inputs": [ + "_t3" + ] + }, + { + "id": "_t6", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t6: EcxVO", + "range": { + "start": 171626, + "end": 171658 + }, + "inputs": [ + "inputs" + ] + }, + { + "id": "_t7", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t7: EcxVVO", + "range": { + "start": 171663, + "end": 171697 + }, + "inputs": [ + "outputs" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxGamma", + "label": "_t1: EcxGamma", + "range": { + "start": 171702, + "end": 171746 + }, + "inputs": [ + "_t2", + "_t6", + "_t7" + ] + }, + { + "id": "_t9", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t9: EcxVVO", + "range": { + "start": 171751, + "end": 171785 + }, + "inputs": [ + "outputs" + ] + }, + { + "id": "_f8", + "kind": "query", + "dsl_type": "EcxVecVecOperand_length", + "label": "_f8: EcxVecVecOperand_length", + "range": { + "start": 171790, + "end": 171837 + }, + "inputs": [ + "_t9" + ] + }, + { + "id": "_t11", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t11: EcxVVO", + "range": { + "start": 171842, + "end": 171877 + }, + "inputs": [ + "outputs" + ] + }, + { + "id": "_t10", + "kind": "query", + "dsl_type": "EcxVecVecOperand_get", + "label": "_t10: EcxVecVecOperand_get", + "range": { + "start": 171882, + "end": 171928 + }, + "inputs": [ + "_t11" + ] + }, + { + "id": "_t12", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t12: EcxVO", + "range": { + "start": 171933, + "end": 171961 + }, + "inputs": [ + "A" + ] + }, + { + "id": "_t14", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t14: EcxVVO", + "range": { + "start": 171966, + "end": 172001 + }, + "inputs": [ + "outputs" + ] + }, + { + "id": "_t13", + "kind": "query", + "dsl_type": "EcxVecVecOperand_get", + "label": "_t13: EcxVecVecOperand_get", + "range": { + "start": 172006, + "end": 172052 + }, + "inputs": [ + "_t14" + ] + }, + { + "id": "_t15", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t15: EcxVO", + "range": { + "start": 172057, + "end": 172085 + }, + "inputs": [ + "B" + ] + }, + { + "id": "_t17", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t17: EcxVO", + "range": { + "start": 172090, + "end": 172123 + }, + "inputs": [ + "inputs" + ] + }, + { + "id": "_f16", + "kind": "query", + "dsl_type": "EcxVecOperand_length", + "label": "_f16: EcxVecOperand_length", + "range": { + "start": 172128, + "end": 172174 + }, + "inputs": [ + "_t17" + ] + }, + { + "id": "_t19", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t19: EcxVO", + "range": { + "start": 172179, + "end": 172207 + }, + "inputs": [ + "B" + ] + }, + { + "id": "_f18", + "kind": "query", + "dsl_type": "EcxVecOperand_length", + "label": "_f18: EcxVecOperand_length", + "range": { + "start": 172212, + "end": 172258 + }, + "inputs": [ + "_t19" + ] + } + ], + "edges": [ + { + "from": "_t4", + "to": "_t5", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "a", + "kind": "operand", + "index": 1 + }, + { + "from": "_t4", + "to": "b", + "kind": "operand", + "index": 2 + }, + { + "from": "_t3", + "to": "_t4", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "_t3", + "kind": "operand", + "index": 0 + }, + { + "from": "_t6", + "to": "inputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t7", + "to": "outputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t6", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "_t7", + "kind": "operand", + "index": 2 + }, + { + "from": "_t9", + "to": "outputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_f8", + "to": "_t9", + "kind": "operand", + "index": 0 + }, + { + "from": "_t11", + "to": "outputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t10", + "to": "_t11", + "kind": "operand", + "index": 0 + }, + { + "from": "_t12", + "to": "A", + "kind": "operand", + "index": 0 + }, + { + "from": "_t14", + "to": "outputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t13", + "to": "_t14", + "kind": "operand", + "index": 0 + }, + { + "from": "_t15", + "to": "B", + "kind": "operand", + "index": 0 + }, + { + "from": "_t17", + "to": "inputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_f16", + "to": "_t17", + "kind": "operand", + "index": 0 + }, + { + "from": "_t19", + "to": "B", + "kind": "operand", + "index": 0 + }, + { + "from": "_f18", + "to": "_t19", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "A", + "B", + "a", + "args", + "b", + "gamma", + "inputs", + "outputs", + "rets", + "_t1", + "_t2", + "_t3", + "_t4", + "_t5", + "_t6", + "_t7", + "_f8", + "_t9", + "_t10", + "_t11", + "_t12", + "_t13", + "_t14", + "_t15", + "_f16", + "_t17", + "_f18", + "_t19" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "gamma.handle().eq(&_t1.handle())", + "semantic_text": "gamma == _t1", + "referenced_vars": [ + "_t1", + "gamma" + ], + "range": { + "start": 172842, + "end": 172844 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "_f8.handle().eq(&(&(2_i64)).as_handle())", + "semantic_text": "_f8 == 2", + "referenced_vars": [ + "_f8" + ], + "range": { + "start": 172858, + "end": 172860 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "_t10.handle_a1().eq(&(1_i64))", + "semantic_text": "_t10.a1 == 1", + "referenced_vars": [ + "_t10" + ], + "range": { + "start": 172874, + "end": 172876 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "_t10.handle().eq(&_t12.handle())", + "semantic_text": "_t10 == _t12", + "referenced_vars": [ + "_t10", + "_t12" + ], + "range": { + "start": 172890, + "end": 172892 + } + }, + { + "id": "constraint_4", + "source_text": "c4", + "resolved_text": "_t13.handle_a1().eq(&(0_i64))", + "semantic_text": "_t13.a1 == 0", + "referenced_vars": [ + "_t13" + ], + "range": { + "start": 172906, + "end": 172908 + } + }, + { + "id": "constraint_5", + "source_text": "c5", + "resolved_text": "_t13.handle().eq(&_t15.handle())", + "semantic_text": "_t13 == _t15", + "referenced_vars": [ + "_t13", + "_t15" + ], + "range": { + "start": 172922, + "end": 172924 + } + }, + { + "id": "constraint_6", + "source_text": "c6", + "resolved_text": "args.handle().eq(&_f16.handle())", + "semantic_text": "args == _f16", + "referenced_vars": [ + "_f16", + "args" + ], + "range": { + "start": 172938, + "end": 172940 + } + }, + { + "id": "constraint_7", + "source_text": "c7", + "resolved_text": "rets.handle().eq(&_f18.handle())", + "semantic_text": "rets == _f18", + "referenced_vars": [ + "_f18", + "rets" + ], + "range": { + "start": 172954, + "end": 172956 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@246856:246897", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_arg(ctx.devalue(pat.args))", + "semantic_text": null, + "referenced_pat_vars": [ + "args" + ], + "referenced_action_vars": [], + "range": { + "start": 246856, + "end": 246897 + } + }, + { + "id": "effect_1", + "effect_id": "effect@246916:246976", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_pass_through_arguments(ctx.devalue(pat.args))", + "semantic_text": null, + "referenced_pat_vars": [ + "args" + ], + "referenced_action_vars": [], + "range": { + "start": 246916, + "end": 246976 + } + }, + { + "id": "effect_2", + "effect_id": "effect@246995:247019", + "bound_var": "t5", + "source_text": "ctx.insert_ecx_vo(pat.B)", + "semantic_text": null, + "referenced_pat_vars": [ + "B" + ], + "referenced_action_vars": [], + "range": { + "start": 246995, + "end": 247019 + } + }, + { + "id": "effect_3", + "effect_id": "effect@247038:247062", + "bound_var": "t6", + "source_text": "ctx.insert_ecx_vo(pat.A)", + "semantic_text": null, + "referenced_pat_vars": [ + "A" + ], + "referenced_action_vars": [], + "range": { + "start": 247038, + "end": 247062 + } + }, + { + "id": "effect_4", + "effect_id": "effect@247081:247295", + "bound_var": "t4", + "source_text": "ctx.insert_ecx_vvo(\n ctx.intern_container::>(\n VecContainer::::from(vec![t5.erase(), t6.erase()]),\n ),\n )", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 247081, + "end": 247295 + } + }, + { + "id": "effect_5", + "effect_id": "effect@247314:247346", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_gamma(t2, t3, t4)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t2", + "t3", + "t4" + ], + "range": { + "start": 247314, + "end": 247346 + } + }, + { + "id": "effect_6", + "effect_id": "effect@247389:247642", + "bound_var": "t8", + "source_text": "ctx.insert_ecx_vo(\n ctx.intern_container::>(vec_push::<\n EcxOperand,\n >(\n &*ctx.devalue(pat.inputs),\n pat.b.erase(),\n )),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "inputs" + ], + "referenced_action_vars": [], + "range": { + "start": 247389, + "end": 247642 + } + }, + { + "id": "effect_7", + "effect_id": "effect@247662:247726", + "bound_var": "t10", + "source_text": "ctx.insert_ecx_body_to_vec_operand(ctx.devalue(pat.rets), inner)", + "semantic_text": null, + "referenced_pat_vars": [ + "rets" + ], + "referenced_action_vars": [], + "range": { + "start": 247662, + "end": 247726 + } + }, + { + "id": "effect_8", + "effect_id": "effect@247746:247770", + "bound_var": "t11", + "source_text": "ctx.insert_ecx_vo(pat.A)", + "semantic_text": null, + "referenced_pat_vars": [ + "A" + ], + "referenced_action_vars": [], + "range": { + "start": 247746, + "end": 247770 + } + }, + { + "id": "effect_9", + "effect_id": "effect@247789:248005", + "bound_var": "t9", + "source_text": "ctx.insert_ecx_vvo(\n ctx.intern_container::>(\n VecContainer::::from(vec![t10.erase(), t11.erase()]),\n ),\n )", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 247789, + "end": 248005 + } + }, + { + "id": "effect_10", + "effect_id": "effect@248024:248059", + "bound_var": "t7", + "source_text": "ctx.insert_ecx_gamma(pat.a, t8, t9)", + "semantic_text": null, + "referenced_pat_vars": [ + "a" + ], + "referenced_action_vars": [ + "t8", + "t9" + ], + "range": { + "start": 248024, + "end": 248059 + } + }, + { + "id": "effect_11", + "effect_id": "effect@248069:248093", + "bound_var": null, + "source_text": "ctx.union(pat.gamma, t7)", + "semantic_text": null, + "referenced_pat_vars": [ + "gamma" + ], + "referenced_action_vars": [ + "t7" + ], + "range": { + "start": 248069, + "end": 248093 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0183", + "premises": [ + { + "target_id": "args", + "label": "args: ", + "plain_source": "upright(\"args\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"args\") $]" + }, + { + "target_id": "rets", + "label": "rets: ", + "plain_source": "upright(\"rets\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rets\") $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxGamma", + "plain_source": "upright(\"Gamma\")((upright(\"Node\")((upright(\"PureOp\")((upright(\"bor\")(upright(\"BoolT\"), a, b)))))), (upright(\"VO\")(upright(\"inputs\"))), (upright(\"VVO\")(upright(\"outputs\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bor\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $])) $])) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxNode", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"bor\")(upright(\"BoolT\"), a, b)))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bor\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $])) $])) $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxPureOp", + "plain_source": "upright(\"PureOp\")((upright(\"bor\")(upright(\"BoolT\"), a, b)))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bor\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $])) $]" + }, + { + "target_id": "_t4", + "label": "_t4: Ecxbor", + "plain_source": "upright(\"bor\")(upright(\"BoolT\"), a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bor\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + }, + { + "target_id": "_t5", + "label": "_t5: EcxBoolT", + "plain_source": "upright(\"BoolT\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $]" + }, + { + "target_id": "_t6", + "label": "_t6: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"inputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $]" + }, + { + "target_id": "_t7", + "label": "_t7: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "_f8", + "label": "_f8: EcxVecVecOperand_length", + "plain_source": "upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(upright(\"outputs\")))", + "colored_source": "upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])" + }, + { + "target_id": "_t9", + "label": "_t9: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "_t10", + "label": "_t10: EcxVecVecOperand_get", + "plain_source": "upright(\"_t10\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $]" + }, + { + "target_id": "_t11", + "label": "_t11: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "_t12", + "label": "_t12: EcxVO", + "plain_source": "upright(\"VO\")(A)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ A $]) $]" + }, + { + "target_id": "_t13", + "label": "_t13: EcxVecVecOperand_get", + "plain_source": "upright(\"_t13\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t13\") $]" + }, + { + "target_id": "_t14", + "label": "_t14: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "_t15", + "label": "_t15: EcxVO", + "plain_source": "upright(\"VO\")(B)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ B $]) $]" + }, + { + "target_id": "_f16", + "label": "_f16: EcxVecOperand_length", + "plain_source": "upright(\"EcxVecOperand_length\")(upright(\"VO\")(upright(\"inputs\")))", + "colored_source": "upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $])" + }, + { + "target_id": "_t17", + "label": "_t17: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"inputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $]" + }, + { + "target_id": "_f18", + "label": "_f18: EcxVecOperand_length", + "plain_source": "upright(\"EcxVecOperand_length\")(upright(\"VO\")(B))", + "colored_source": "upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ B $]) $])" + }, + { + "target_id": "_t19", + "label": "_t19: EcxVO", + "plain_source": "upright(\"VO\")(B)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ B $]) $]" + } + ], + "side_conditions": [ + "upright(\"gamma\") == upright(\"_t1\")", + "upright(\"_f8\") == 2", + "upright(\"_t10.a1\") == 1", + "upright(\"_t10\") == upright(\"_t12\")", + "upright(\"_t13.a1\") == 0", + "upright(\"_t13\") == upright(\"_t15\")", + "upright(\"args\") == upright(\"_f16\")", + "upright(\"rets\") == upright(\"_f18\")" + ], + "derivations": [ + { + "target_id": "effect:effect_6", + "label": "t8", + "plain_source": "upright(\"EcxVo\")(upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"inputs\"), upright(\"b.erase\")())))", + "colored_source": "upright(\"EcxVo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"inputs\"), upright(\"b.erase\")())) $])" + }, + { + "target_id": "effect:effect_9", + "label": "t9", + "plain_source": "upright(\"EcxVvo\")(upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"from\")(upright(\"vec\")![upright(\"t10.erase\")(), upright(\"t11.erase\")()])))", + "colored_source": "upright(\"EcxVvo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"from\")(upright(\"vec\")![upright(\"t10.erase\")(), upright(\"t11.erase\")()])) $])" + }, + { + "target_id": "effect:effect_10", + "label": "t7", + "plain_source": "upright(\"Gamma\")(a, upright(\"EcxVo\")(upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"inputs\"), upright(\"b.erase\")()))), upright(\"EcxVvo\")(upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"from\")(upright(\"vec\")![upright(\"t10.erase\")(), upright(\"t11.erase\")()]))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], upright(\"EcxVo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"inputs\"), upright(\"b.erase\")())) $]), upright(\"EcxVvo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"from\")(upright(\"vec\")![upright(\"t10.erase\")(), upright(\"t11.erase\")()])) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_11", + "from": { + "target_id": "gamma", + "label": "gamma: EcxBody", + "plain_source": "upright(\"gamma\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"gamma\") $]" + }, + "to": { + "target_id": "effect:effect_10", + "label": "t7", + "plain_source": "upright(\"Gamma\")(a, upright(\"EcxVo\")(upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"inputs\"), upright(\"b.erase\")()))), upright(\"EcxVvo\")(upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"from\")(upright(\"vec\")![upright(\"t10.erase\")(), upright(\"t11.erase\")()]))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], upright(\"EcxVo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"inputs\"), upright(\"b.erase\")())) $]), upright(\"EcxVvo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"from\")(upright(\"vec\")![upright(\"t10.erase\")(), upright(\"t11.erase\")()])) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"args\") \\ upright(\"rets\") \\ upright(\"Gamma\")((upright(\"Node\")((upright(\"PureOp\")((upright(\"bor\")(upright(\"BoolT\"), a, b)))))), (upright(\"VO\")(upright(\"inputs\"))), (upright(\"VVO\")(upright(\"outputs\")))) \\ upright(\"Node\")((upright(\"PureOp\")((upright(\"bor\")(upright(\"BoolT\"), a, b))))) \\ upright(\"PureOp\")((upright(\"bor\")(upright(\"BoolT\"), a, b))) \\ upright(\"bor\")(upright(\"BoolT\"), a, b) \\ upright(\"BoolT\") \\ upright(\"VO\")(upright(\"inputs\")) \\ upright(\"VVO\")(upright(\"outputs\")) \\ upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(upright(\"outputs\"))) \\ upright(\"VVO\")(upright(\"outputs\")) \\ upright(\"_t10\") \\ upright(\"VVO\")(upright(\"outputs\")) \\ upright(\"VO\")(A) \\ upright(\"_t13\") \\ upright(\"VVO\")(upright(\"outputs\")) \\ upright(\"VO\")(B) \\ upright(\"EcxVecOperand_length\")(upright(\"VO\")(upright(\"inputs\"))) \\ upright(\"VO\")(upright(\"inputs\")) \\ upright(\"EcxVecOperand_length\")(upright(\"VO\")(B)) \\ upright(\"VO\")(B), upright(\"gamma\") arrow.r.double upright(\"Gamma\")(a, upright(\"EcxVo\")(upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"inputs\"), upright(\"b.erase\")()))), upright(\"EcxVvo\")(upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"from\")(upright(\"vec\")![upright(\"t10.erase\")(), upright(\"t11.erase\")()]))))) quad upright(\"if\") quad upright(\"gamma\") == upright(\"_t1\") \\ upright(\"_f8\") == 2 \\ upright(\"_t10.a1\") == 1 \\ upright(\"_t10\") == upright(\"_t12\") \\ upright(\"_t13.a1\") == 0 \\ upright(\"_t13\") == upright(\"_t15\") \\ upright(\"args\") == upright(\"_f16\") \\ upright(\"rets\") == upright(\"_f18\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"args\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rets\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bor\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $])) $])) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bor\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bor\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bor\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $] \\ upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ A $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t13\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ B $]) $] \\ upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $] \\ upright(\"EcxVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ B $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ B $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"gamma\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $], upright(\"EcxVo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"vec_push\")::< upright(\"EcxOperand\"), >(*upright(\"inputs\"), upright(\"b.erase\")())) $]), upright(\"EcxVvo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"from\")(upright(\"vec\")![upright(\"t10.erase\")(), upright(\"t11.erase\")()])) $])) $]) quad upright(\"if\") quad upright(\"gamma\") == upright(\"_t1\") \\ upright(\"_f8\") == 2 \\ upright(\"_t10.a1\") == 1 \\ upright(\"_t10\") == upright(\"_t12\") \\ upright(\"_t13.a1\") == 0 \\ upright(\"_t13\") == upright(\"_t15\") \\ upright(\"args\") == upright(\"_f16\") \\ upright(\"rets\") == upright(\"_f18\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7767_5_MyTxEggccExtraction_add_rule__r0184__839730e23056666b", + "display_name": "r0184", + "rule_name": "r0184", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 248107, + "line": 7767, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 248107, + "end": 248460 + }, + "pattern_range": { + "start": 248158, + "end": 248169 + }, + "action_range": { + "start": 248171, + "end": 248459 + } + }, + "nodes": [ + { + "id": "condition", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "condition: EcxOperand", + "range": { + "start": 173343, + "end": 173384 + }, + "inputs": [] + }, + { + "id": "gamma", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "gamma: EcxBody", + "range": { + "start": 173389, + "end": 173423 + }, + "inputs": [] + }, + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 173428, + "end": 173469 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperandBase", + "label": "outputs: EcxVecVecOperandBase", + "range": { + "start": 173474, + "end": 173523 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t2: EcxVVO", + "range": { + "start": 173528, + "end": 173562 + }, + "inputs": [ + "outputs" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxGamma", + "label": "_t1: EcxGamma", + "range": { + "start": 173567, + "end": 173620 + }, + "inputs": [ + "condition", + "inputs", + "_t2" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t4: EcxVVO", + "range": { + "start": 173625, + "end": 173659 + }, + "inputs": [ + "outputs" + ] + }, + { + "id": "_f3", + "kind": "query", + "dsl_type": "EcxVecVecOperand_length", + "label": "_f3: EcxVecVecOperand_length", + "range": { + "start": 173664, + "end": 173711 + }, + "inputs": [ + "_t4" + ] + }, + { + "id": "_t6", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t6: EcxVVO", + "range": { + "start": 173716, + "end": 173750 + }, + "inputs": [ + "outputs" + ] + }, + { + "id": "_t5", + "kind": "query", + "dsl_type": "EcxVecVecOperand_get", + "label": "_t5: EcxVecVecOperand_get", + "range": { + "start": 173755, + "end": 173799 + }, + "inputs": [ + "_t6" + ] + }, + { + "id": "_t8", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t8: EcxVVO", + "range": { + "start": 173804, + "end": 173838 + }, + "inputs": [ + "outputs" + ] + }, + { + "id": "_t7", + "kind": "query", + "dsl_type": "EcxVecVecOperand_get", + "label": "_t7: EcxVecVecOperand_get", + "range": { + "start": 173843, + "end": 173887 + }, + "inputs": [ + "_t8" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "outputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "condition", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 2 + }, + { + "from": "_t4", + "to": "outputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_f3", + "to": "_t4", + "kind": "operand", + "index": 0 + }, + { + "from": "_t6", + "to": "outputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t5", + "to": "_t6", + "kind": "operand", + "index": 0 + }, + { + "from": "_t8", + "to": "outputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t7", + "to": "_t8", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "condition", + "gamma", + "inputs", + "outputs", + "_t1", + "_t2", + "_f3", + "_t4", + "_t5", + "_t6", + "_t7", + "_t8" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "gamma.handle().eq(&_t1.handle())", + "semantic_text": "gamma == _t1", + "referenced_vars": [ + "_t1", + "gamma" + ], + "range": { + "start": 174240, + "end": 174242 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "_f3.handle().eq(&(&(2_i64)).as_handle())", + "semantic_text": "_f3 == 2", + "referenced_vars": [ + "_f3" + ], + "range": { + "start": 174256, + "end": 174258 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "_t5.handle_a1().eq(&(0_i64))", + "semantic_text": "_t5.a1 == 0", + "referenced_vars": [ + "_t5" + ], + "range": { + "start": 174272, + "end": 174274 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "_t7.handle_a1().eq(&(1_i64))", + "semantic_text": "_t7.a1 == 1", + "referenced_vars": [ + "_t7" + ], + "range": { + "start": 174288, + "end": 174290 + } + }, + { + "id": "constraint_4", + "source_text": "c4", + "resolved_text": "_t5.handle().eq(&_t7.handle())", + "semantic_text": "_t5 == _t7", + "referenced_vars": [ + "_t5", + "_t7" + ], + "range": { + "start": 174304, + "end": 174306 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@248201:248232", + "bound_var": "t4", + "source_text": "ctx.insert_ecx_vvo(pat.outputs)", + "semantic_text": null, + "referenced_pat_vars": [ + "outputs" + ], + "referenced_action_vars": [], + "range": { + "start": 248201, + "end": 248232 + } + }, + { + "id": "effect_1", + "effect_id": "effect@248251:248296", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_vec_vec_operand_get(t4, 0_i64)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t4" + ], + "range": { + "start": 248251, + "end": 248296 + } + }, + { + "id": "effect_2", + "effect_id": "effect@248315:248367", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_vec_operand_all(t3, pat.inputs)", + "semantic_text": null, + "referenced_pat_vars": [ + "inputs" + ], + "referenced_action_vars": [ + "t3" + ], + "range": { + "start": 248315, + "end": 248367 + } + }, + { + "id": "effect_3", + "effect_id": "effect@248386:248418", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_operand_group(t2)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 248386, + "end": 248418 + } + }, + { + "id": "effect_4", + "effect_id": "effect@248428:248452", + "bound_var": null, + "source_text": "ctx.union(pat.gamma, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "gamma" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 248428, + "end": 248452 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0184", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxGamma", + "plain_source": "upright(\"Gamma\")(upright(\"condition\"), upright(\"inputs\"), (upright(\"VVO\")(upright(\"outputs\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"condition\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "_f3", + "label": "_f3: EcxVecVecOperand_length", + "plain_source": "upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(upright(\"outputs\")))", + "colored_source": "upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])" + }, + { + "target_id": "_t4", + "label": "_t4: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "_t5", + "label": "_t5: EcxVecVecOperand_get", + "plain_source": "upright(\"_t5\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $]" + }, + { + "target_id": "_t6", + "label": "_t6: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "_t7", + "label": "_t7: EcxVecVecOperand_get", + "plain_source": "upright(\"_t7\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]" + }, + { + "target_id": "_t8", + "label": "_t8: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + ], + "side_conditions": [ + "upright(\"gamma\") == upright(\"_t1\")", + "upright(\"_f3\") == 2", + "upright(\"_t5.a1\") == 0", + "upright(\"_t7.a1\") == 1", + "upright(\"_t5\") == upright(\"_t7\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t4", + "plain_source": "upright(\"EcxVvo\")(upright(\"outputs\"))", + "colored_source": "upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $])" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(upright(\"outputs\")), 0)", + "colored_source": "upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 0 $])" + }, + { + "target_id": "effect:effect_2", + "label": "t2", + "plain_source": "upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(upright(\"outputs\")), 0), upright(\"inputs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $]" + }, + { + "target_id": "effect:effect_3", + "label": "t1", + "plain_source": "upright(\"OperandGroup\")((upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(upright(\"outputs\")), 0), upright(\"inputs\"))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_4", + "from": { + "target_id": "gamma", + "label": "gamma: EcxBody", + "plain_source": "upright(\"gamma\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"gamma\") $]" + }, + "to": { + "target_id": "effect:effect_3", + "label": "t1", + "plain_source": "upright(\"OperandGroup\")((upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(upright(\"outputs\")), 0), upright(\"inputs\"))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"Gamma\")(upright(\"condition\"), upright(\"inputs\"), (upright(\"VVO\")(upright(\"outputs\")))) \\ upright(\"VVO\")(upright(\"outputs\")) \\ upright(\"EcxVecVecOperand_length\")(upright(\"VVO\")(upright(\"outputs\"))) \\ upright(\"VVO\")(upright(\"outputs\")) \\ upright(\"_t5\") \\ upright(\"VVO\")(upright(\"outputs\")) \\ upright(\"_t7\") \\ upright(\"VVO\")(upright(\"outputs\")), upright(\"gamma\") arrow.r.double upright(\"OperandGroup\")((upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(upright(\"outputs\")), 0), upright(\"inputs\"))))) quad upright(\"if\") quad upright(\"gamma\") == upright(\"_t1\") \\ upright(\"_f3\") == 2 \\ upright(\"_t5.a1\") == 0 \\ upright(\"_t7.a1\") == 1 \\ upright(\"_t5\") == upright(\"_t7\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"condition\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $] \\ upright(\"EcxVecVecOperand_length\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"gamma\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $])) $]) quad upright(\"if\") quad upright(\"gamma\") == upright(\"_t1\") \\ upright(\"_f3\") == 2 \\ upright(\"_t5.a1\") == 0 \\ upright(\"_t7.a1\") == 1 \\ upright(\"_t5\") == upright(\"_t7\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7774_5_MyTxEggccExtraction_add_rule__r0185__c6e2b1a1c5053eb4", + "display_name": "r0185", + "rule_name": "r0185", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 248466, + "line": 7774, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 248466, + "end": 249495 + }, + "pattern_range": { + "start": 248517, + "end": 248528 + }, + "action_range": { + "start": 248530, + "end": 249494 + } + }, + "nodes": [ + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "inputs: EcxVecOperandBase", + "range": { + "start": 174577, + "end": 174622 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "outputs: EcxVecOperandBase", + "range": { + "start": 174627, + "end": 174673 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 174678, + "end": 174714 + }, + "inputs": [] + }, + { + "id": "theta", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "theta: EcxBody", + "range": { + "start": 174719, + "end": 174753 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t2: EcxVO", + "range": { + "start": 174758, + "end": 174790 + }, + "inputs": [ + "inputs" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t3: EcxVO", + "range": { + "start": 174795, + "end": 174828 + }, + "inputs": [ + "outputs" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxTheta", + "label": "_t1: EcxTheta", + "range": { + "start": 174833, + "end": 174878 + }, + "inputs": [ + "pred", + "_t2", + "_t3" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "inputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t3", + "to": "outputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "_t3", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "inputs", + "outputs", + "pred", + "theta", + "_t1", + "_t2", + "_t3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "theta.handle().eq(&_t1.handle())", + "semantic_text": "theta == _t1", + "referenced_vars": [ + "_t1", + "theta" + ], + "range": { + "start": 174995, + "end": 174997 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@248560:248590", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_vo(pat.outputs)", + "semantic_text": null, + "referenced_pat_vars": [ + "outputs" + ], + "referenced_action_vars": [], + "range": { + "start": 248560, + "end": 248590 + } + }, + { + "id": "effect_1", + "effect_id": "effect@248609:248638", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_vo(pat.inputs)", + "semantic_text": null, + "referenced_pat_vars": [ + "inputs" + ], + "referenced_action_vars": [], + "range": { + "start": 248609, + "end": 248638 + } + }, + { + "id": "effect_2", + "effect_id": "effect@248657:248701", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_subst_vec_operand_all(t2, t3)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 248657, + "end": 248701 + } + }, + { + "id": "effect_3", + "effect_id": "effect@248753:248827", + "bound_var": "t4", + "source_text": "ctx.insert_ecx_pass_through_arguments(vec_len(&*ctx.devalue(pat.outputs)))", + "semantic_text": null, + "referenced_pat_vars": [ + "outputs" + ], + "referenced_action_vars": [], + "range": { + "start": 248753, + "end": 248827 + } + }, + { + "id": "effect_4", + "effect_id": "effect@248877:248935", + "bound_var": "t6", + "source_text": "ctx.insert_ecx_subst_operand_all(pat.pred, after_one_iter)", + "semantic_text": null, + "referenced_pat_vars": [ + "pred" + ], + "referenced_action_vars": [], + "range": { + "start": 248877, + "end": 248935 + } + }, + { + "id": "effect_5", + "effect_id": "effect@248955:248985", + "bound_var": "t10", + "source_text": "ctx.insert_ecx_vo(pat.outputs)", + "semantic_text": null, + "referenced_pat_vars": [ + "outputs" + ], + "referenced_action_vars": [], + "range": { + "start": 248955, + "end": 248985 + } + }, + { + "id": "effect_6", + "effect_id": "effect@249004:249053", + "bound_var": "t9", + "source_text": "ctx.insert_ecx_theta(pat.pred, pass_through, t10)", + "semantic_text": null, + "referenced_pat_vars": [ + "pred" + ], + "referenced_action_vars": [ + "t10" + ], + "range": { + "start": 249004, + "end": 249053 + } + }, + { + "id": "effect_7", + "effect_id": "effect@249072:249147", + "bound_var": "t8", + "source_text": "ctx.insert_ecx_body_to_vec_operand(vec_len(&*ctx.devalue(pat.outputs)), t9)", + "semantic_text": null, + "referenced_pat_vars": [ + "outputs" + ], + "referenced_action_vars": [ + "t9" + ], + "range": { + "start": 249072, + "end": 249147 + } + }, + { + "id": "effect_8", + "effect_id": "effect@249166:249390", + "bound_var": "t7", + "source_text": "ctx.insert_ecx_vvo(\n ctx.intern_container::>(\n VecContainer::::from(vec![pass_through.erase(), t8.erase()]),\n ),\n )", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 249166, + "end": 249390 + } + }, + { + "id": "effect_9", + "effect_id": "effect@249409:249453", + "bound_var": "t5", + "source_text": "ctx.insert_ecx_gamma(t6, after_one_iter, t7)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t6", + "t7" + ], + "range": { + "start": 249409, + "end": 249453 + } + }, + { + "id": "effect_10", + "effect_id": "effect@249463:249487", + "bound_var": null, + "source_text": "ctx.union(pat.theta, t5)", + "semantic_text": null, + "referenced_pat_vars": [ + "theta" + ], + "referenced_action_vars": [ + "t5" + ], + "range": { + "start": 249463, + "end": 249487 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0185", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxTheta", + "plain_source": "upright(\"Theta\")(upright(\"pred\"), (upright(\"VO\")(upright(\"inputs\"))), (upright(\"VO\")(upright(\"outputs\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"inputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + } + ], + "side_conditions": [ + "upright(\"theta\") == upright(\"_t1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_4", + "label": "t6", + "plain_source": "upright(\"SubstOperandAll\")(upright(\"pred\"), upright(\"after_one_iter\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"after_one_iter\") $]) $]" + }, + { + "target_id": "effect:effect_8", + "label": "t7", + "plain_source": "upright(\"EcxVvo\")(upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"from\")(upright(\"vec\")![upright(\"pass_through.erase\")(), upright(\"t8.erase\")()])))", + "colored_source": "upright(\"EcxVvo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"from\")(upright(\"vec\")![upright(\"pass_through.erase\")(), upright(\"t8.erase\")()])) $])" + }, + { + "target_id": "effect:effect_9", + "label": "t5", + "plain_source": "upright(\"Gamma\")((upright(\"SubstOperandAll\")(upright(\"pred\"), upright(\"after_one_iter\"))), upright(\"after_one_iter\"), upright(\"EcxVvo\")(upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"from\")(upright(\"vec\")![upright(\"pass_through.erase\")(), upright(\"t8.erase\")()]))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"after_one_iter\") $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ upright(\"after_one_iter\") $], upright(\"EcxVvo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"from\")(upright(\"vec\")![upright(\"pass_through.erase\")(), upright(\"t8.erase\")()])) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_10", + "from": { + "target_id": "theta", + "label": "theta: EcxBody", + "plain_source": "upright(\"theta\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"theta\") $]" + }, + "to": { + "target_id": "effect:effect_9", + "label": "t5", + "plain_source": "upright(\"Gamma\")((upright(\"SubstOperandAll\")(upright(\"pred\"), upright(\"after_one_iter\"))), upright(\"after_one_iter\"), upright(\"EcxVvo\")(upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"from\")(upright(\"vec\")![upright(\"pass_through.erase\")(), upright(\"t8.erase\")()]))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"after_one_iter\") $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ upright(\"after_one_iter\") $], upright(\"EcxVvo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"from\")(upright(\"vec\")![upright(\"pass_through.erase\")(), upright(\"t8.erase\")()])) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"Theta\")(upright(\"pred\"), (upright(\"VO\")(upright(\"inputs\"))), (upright(\"VO\")(upright(\"outputs\")))) \\ upright(\"VO\")(upright(\"inputs\")) \\ upright(\"VO\")(upright(\"outputs\")), upright(\"theta\") arrow.r.double upright(\"Gamma\")((upright(\"SubstOperandAll\")(upright(\"pred\"), upright(\"after_one_iter\"))), upright(\"after_one_iter\"), upright(\"EcxVvo\")(upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"from\")(upright(\"vec\")![upright(\"pass_through.erase\")(), upright(\"t8.erase\")()]))))) quad upright(\"if\") quad upright(\"theta\") == upright(\"_t1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Theta\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $]), (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"theta\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"Gamma\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"after_one_iter\") $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ upright(\"after_one_iter\") $], upright(\"EcxVvo\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"intern_container\")::>(upright(\"VecContainer\")::::upright(\"from\")(upright(\"vec\")![upright(\"pass_through.erase\")(), upright(\"t8.erase\")()])) $])) $]) quad upright(\"if\") quad upright(\"theta\") == upright(\"_t1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7793_5_MyTxEggccExtraction_add_rule__r0186__474a372325882502", + "display_name": "r0186", + "rule_name": "r0186", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 249501, + "line": 7793, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 249501, + "end": 249804 + }, + "pattern_range": { + "start": 249552, + "end": 249563 + }, + "action_range": { + "start": 249565, + "end": 249803 + } + }, + "nodes": [ + { + "id": "ha", + "kind": "query", + "dsl_type": "", + "label": "ha: ", + "range": { + "start": 175232, + "end": 175279 + }, + "inputs": [] + }, + { + "id": "hb", + "kind": "query", + "dsl_type": "", + "label": "hb: ", + "range": { + "start": 175284, + "end": 175331 + }, + "inputs": [] + }, + { + "id": "la", + "kind": "query", + "dsl_type": "", + "label": "la: ", + "range": { + "start": 175336, + "end": 175383 + }, + "inputs": [] + }, + { + "id": "lb", + "kind": "query", + "dsl_type": "", + "label": "lb: ", + "range": { + "start": 175388, + "end": 175435 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxIntI", + "label": "_t2: EcxIntI", + "range": { + "start": 175440, + "end": 175467 + }, + "inputs": [] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxIntI", + "label": "_t3: EcxIntI", + "range": { + "start": 175472, + "end": 175499 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "Ecxinterval_intersect", + "label": "_t1: Ecxinterval_intersect", + "range": { + "start": 175504, + "end": 175555 + }, + "inputs": [ + "_t2", + "_t3" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t3", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "ha", + "hb", + "la", + "lb", + "_t1", + "_t2", + "_t3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "la.handle().eq(&_t2.handle_a0())", + "semantic_text": "la == _t2.a0", + "referenced_vars": [ + "_t2", + "la" + ], + "range": { + "start": 175808, + "end": 175810 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "ha.handle().eq(&_t2.handle_a1())", + "semantic_text": "ha == _t2.a1", + "referenced_vars": [ + "_t2", + "ha" + ], + "range": { + "start": 175828, + "end": 175830 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "lb.handle().eq(&_t3.handle_a0())", + "semantic_text": "lb == _t3.a0", + "referenced_vars": [ + "_t3", + "lb" + ], + "range": { + "start": 175848, + "end": 175850 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "hb.handle().eq(&_t3.handle_a1())", + "semantic_text": "hb == _t3.a1", + "referenced_vars": [ + "_t3", + "hb" + ], + "range": { + "start": 175868, + "end": 175870 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@249595:249764", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_int_i(\n std::cmp::max(ctx.devalue(pat.la), ctx.devalue(pat.lb)),\n std::cmp::min(ctx.devalue(pat.ha), ctx.devalue(pat.hb)),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "ha", + "hb", + "la", + "lb" + ], + "referenced_action_vars": [], + "range": { + "start": 249595, + "end": 249764 + } + }, + { + "id": "effect_1", + "effect_id": "effect@249774:249796", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 249774, + "end": 249796 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0186", + "premises": [ + { + "target_id": "ha", + "label": "ha: ", + "plain_source": "upright(\"ha\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ha\") $]" + }, + { + "target_id": "hb", + "label": "hb: ", + "plain_source": "upright(\"hb\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"hb\") $]" + }, + { + "target_id": "la", + "label": "la: ", + "plain_source": "upright(\"la\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"la\") $]" + }, + { + "target_id": "lb", + "label": "lb: ", + "plain_source": "upright(\"lb\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lb\") $]" + }, + { + "target_id": "_t1", + "label": "_t1: Ecxinterval_intersect", + "plain_source": "upright(\"interval_intersect\")(upright(\"_t2\"), upright(\"_t3\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"interval_intersect\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxIntI", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxIntI", + "plain_source": "upright(\"_t3\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]" + } + ], + "side_conditions": [ + "upright(\"la\") == upright(\"_t2.a0\")", + "upright(\"ha\") == upright(\"_t2.a1\")", + "upright(\"lb\") == upright(\"_t3.a0\")", + "upright(\"hb\") == upright(\"_t3.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"IntI\")(upright(\"std\")::upright(\"cmp\")::upright(\"max\")(upright(\"la\"), upright(\"lb\")), upright(\"std\")::upright(\"cmp\")::upright(\"min\")(upright(\"ha\"), upright(\"hb\")))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntI\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"std\")::upright(\"cmp\")::upright(\"max\")(upright(\"la\"), upright(\"lb\")) $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"std\")::upright(\"cmp\")::upright(\"min\")(upright(\"ha\"), upright(\"hb\")) $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "_t1", + "label": "_t1: Ecxinterval_intersect", + "plain_source": "upright(\"interval_intersect\")(upright(\"_t2\"), upright(\"_t3\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"interval_intersect\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"IntI\")(upright(\"std\")::upright(\"cmp\")::upright(\"max\")(upright(\"la\"), upright(\"lb\")), upright(\"std\")::upright(\"cmp\")::upright(\"min\")(upright(\"ha\"), upright(\"hb\")))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntI\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"std\")::upright(\"cmp\")::upright(\"max\")(upright(\"la\"), upright(\"lb\")) $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"std\")::upright(\"cmp\")::upright(\"min\")(upright(\"ha\"), upright(\"hb\")) $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"ha\") \\ upright(\"hb\") \\ upright(\"la\") \\ upright(\"lb\") \\ upright(\"interval_intersect\")(upright(\"_t2\"), upright(\"_t3\")) \\ upright(\"_t2\") \\ upright(\"_t3\"), upright(\"interval_intersect\")(upright(\"_t2\"), upright(\"_t3\")) arrow.r.double upright(\"IntI\")(upright(\"std\")::upright(\"cmp\")::upright(\"max\")(upright(\"la\"), upright(\"lb\")), upright(\"std\")::upright(\"cmp\")::upright(\"min\")(upright(\"ha\"), upright(\"hb\")))) quad upright(\"if\") quad upright(\"la\") == upright(\"_t2.a0\") \\ upright(\"ha\") == upright(\"_t2.a1\") \\ upright(\"lb\") == upright(\"_t3.a0\") \\ upright(\"hb\") == upright(\"_t3.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ha\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"hb\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"la\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lb\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"interval_intersect\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"interval_intersect\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntI\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"std\")::upright(\"cmp\")::upright(\"max\")(upright(\"la\"), upright(\"lb\")) $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"std\")::upright(\"cmp\")::upright(\"min\")(upright(\"ha\"), upright(\"hb\")) $]) $]) quad upright(\"if\") quad upright(\"la\") == upright(\"_t2.a0\") \\ upright(\"ha\") == upright(\"_t2.a1\") \\ upright(\"lb\") == upright(\"_t3.a0\") \\ upright(\"hb\") == upright(\"_t3.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7800_5_MyTxEggccExtraction_add_rule__r0187__5512c6fdcf456084", + "display_name": "r0187", + "rule_name": "r0187", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 249810, + "line": 7800, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 249810, + "end": 250113 + }, + "pattern_range": { + "start": 249861, + "end": 249872 + }, + "action_range": { + "start": 249874, + "end": 250112 + } + }, + "nodes": [ + { + "id": "ha", + "kind": "query", + "dsl_type": "", + "label": "ha: ", + "range": { + "start": 176101, + "end": 176148 + }, + "inputs": [] + }, + { + "id": "hb", + "kind": "query", + "dsl_type": "", + "label": "hb: ", + "range": { + "start": 176153, + "end": 176200 + }, + "inputs": [] + }, + { + "id": "la", + "kind": "query", + "dsl_type": "", + "label": "la: ", + "range": { + "start": 176205, + "end": 176252 + }, + "inputs": [] + }, + { + "id": "lb", + "kind": "query", + "dsl_type": "", + "label": "lb: ", + "range": { + "start": 176257, + "end": 176304 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxIntI", + "label": "_t2: EcxIntI", + "range": { + "start": 176309, + "end": 176336 + }, + "inputs": [] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxIntI", + "label": "_t3: EcxIntI", + "range": { + "start": 176341, + "end": 176368 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "Ecxinterval_union", + "label": "_t1: Ecxinterval_union", + "range": { + "start": 176373, + "end": 176420 + }, + "inputs": [ + "_t2", + "_t3" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t3", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "ha", + "hb", + "la", + "lb", + "_t1", + "_t2", + "_t3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "la.handle().eq(&_t2.handle_a0())", + "semantic_text": "la == _t2.a0", + "referenced_vars": [ + "_t2", + "la" + ], + "range": { + "start": 176673, + "end": 176675 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "ha.handle().eq(&_t2.handle_a1())", + "semantic_text": "ha == _t2.a1", + "referenced_vars": [ + "_t2", + "ha" + ], + "range": { + "start": 176693, + "end": 176695 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "lb.handle().eq(&_t3.handle_a0())", + "semantic_text": "lb == _t3.a0", + "referenced_vars": [ + "_t3", + "lb" + ], + "range": { + "start": 176713, + "end": 176715 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "hb.handle().eq(&_t3.handle_a1())", + "semantic_text": "hb == _t3.a1", + "referenced_vars": [ + "_t3", + "hb" + ], + "range": { + "start": 176733, + "end": 176735 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@249904:250073", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_int_i(\n std::cmp::min(ctx.devalue(pat.la), ctx.devalue(pat.lb)),\n std::cmp::max(ctx.devalue(pat.ha), ctx.devalue(pat.hb)),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "ha", + "hb", + "la", + "lb" + ], + "referenced_action_vars": [], + "range": { + "start": 249904, + "end": 250073 + } + }, + { + "id": "effect_1", + "effect_id": "effect@250083:250105", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 250083, + "end": 250105 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0187", + "premises": [ + { + "target_id": "ha", + "label": "ha: ", + "plain_source": "upright(\"ha\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ha\") $]" + }, + { + "target_id": "hb", + "label": "hb: ", + "plain_source": "upright(\"hb\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"hb\") $]" + }, + { + "target_id": "la", + "label": "la: ", + "plain_source": "upright(\"la\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"la\") $]" + }, + { + "target_id": "lb", + "label": "lb: ", + "plain_source": "upright(\"lb\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lb\") $]" + }, + { + "target_id": "_t1", + "label": "_t1: Ecxinterval_union", + "plain_source": "upright(\"interval_union\")(upright(\"_t2\"), upright(\"_t3\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"interval_union\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxIntI", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxIntI", + "plain_source": "upright(\"_t3\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]" + } + ], + "side_conditions": [ + "upright(\"la\") == upright(\"_t2.a0\")", + "upright(\"ha\") == upright(\"_t2.a1\")", + "upright(\"lb\") == upright(\"_t3.a0\")", + "upright(\"hb\") == upright(\"_t3.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"IntI\")(upright(\"std\")::upright(\"cmp\")::upright(\"min\")(upright(\"la\"), upright(\"lb\")), upright(\"std\")::upright(\"cmp\")::upright(\"max\")(upright(\"ha\"), upright(\"hb\")))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntI\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"std\")::upright(\"cmp\")::upright(\"min\")(upright(\"la\"), upright(\"lb\")) $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"std\")::upright(\"cmp\")::upright(\"max\")(upright(\"ha\"), upright(\"hb\")) $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "_t1", + "label": "_t1: Ecxinterval_union", + "plain_source": "upright(\"interval_union\")(upright(\"_t2\"), upright(\"_t3\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"interval_union\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"IntI\")(upright(\"std\")::upright(\"cmp\")::upright(\"min\")(upright(\"la\"), upright(\"lb\")), upright(\"std\")::upright(\"cmp\")::upright(\"max\")(upright(\"ha\"), upright(\"hb\")))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntI\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"std\")::upright(\"cmp\")::upright(\"min\")(upright(\"la\"), upright(\"lb\")) $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"std\")::upright(\"cmp\")::upright(\"max\")(upright(\"ha\"), upright(\"hb\")) $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"ha\") \\ upright(\"hb\") \\ upright(\"la\") \\ upright(\"lb\") \\ upright(\"interval_union\")(upright(\"_t2\"), upright(\"_t3\")) \\ upright(\"_t2\") \\ upright(\"_t3\"), upright(\"interval_union\")(upright(\"_t2\"), upright(\"_t3\")) arrow.r.double upright(\"IntI\")(upright(\"std\")::upright(\"cmp\")::upright(\"min\")(upright(\"la\"), upright(\"lb\")), upright(\"std\")::upright(\"cmp\")::upright(\"max\")(upright(\"ha\"), upright(\"hb\")))) quad upright(\"if\") quad upright(\"la\") == upright(\"_t2.a0\") \\ upright(\"ha\") == upright(\"_t2.a1\") \\ upright(\"lb\") == upright(\"_t3.a0\") \\ upright(\"hb\") == upright(\"_t3.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ha\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"hb\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"la\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lb\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"interval_union\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"interval_union\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntI\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"std\")::upright(\"cmp\")::upright(\"min\")(upright(\"la\"), upright(\"lb\")) $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"std\")::upright(\"cmp\")::upright(\"max\")(upright(\"ha\"), upright(\"hb\")) $]) $]) quad upright(\"if\") quad upright(\"la\") == upright(\"_t2.a0\") \\ upright(\"ha\") == upright(\"_t2.a1\") \\ upright(\"lb\") == upright(\"_t3.a0\") \\ upright(\"hb\") == upright(\"_t3.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7807_5_MyTxEggccExtraction_add_rule__r0188__dcc13b8271404630", + "display_name": "r0188", + "rule_name": "r0188", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 250119, + "line": 7807, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 250119, + "end": 250401 + }, + "pattern_range": { + "start": 250170, + "end": 250181 + }, + "action_range": { + "start": 250183, + "end": 250400 + } + }, + "nodes": [ + { + "id": "ha", + "kind": "query", + "dsl_type": "", + "label": "ha: ", + "range": { + "start": 176976, + "end": 177024 + }, + "inputs": [] + }, + { + "id": "hb", + "kind": "query", + "dsl_type": "", + "label": "hb: ", + "range": { + "start": 177029, + "end": 177077 + }, + "inputs": [] + }, + { + "id": "la", + "kind": "query", + "dsl_type": "", + "label": "la: ", + "range": { + "start": 177082, + "end": 177130 + }, + "inputs": [] + }, + { + "id": "lb", + "kind": "query", + "dsl_type": "", + "label": "lb: ", + "range": { + "start": 177135, + "end": 177183 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxBoolI", + "label": "_t2: EcxBoolI", + "range": { + "start": 177188, + "end": 177216 + }, + "inputs": [] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxBoolI", + "label": "_t3: EcxBoolI", + "range": { + "start": 177221, + "end": 177249 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "Ecxinterval_intersect", + "label": "_t1: Ecxinterval_intersect", + "range": { + "start": 177254, + "end": 177305 + }, + "inputs": [ + "_t2", + "_t3" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t3", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "ha", + "hb", + "la", + "lb", + "_t1", + "_t2", + "_t3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "la.handle().eq(&_t2.handle_a0())", + "semantic_text": "la == _t2.a0", + "referenced_vars": [ + "_t2", + "la" + ], + "range": { + "start": 177558, + "end": 177560 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "ha.handle().eq(&_t2.handle_a1())", + "semantic_text": "ha == _t2.a1", + "referenced_vars": [ + "_t2", + "ha" + ], + "range": { + "start": 177578, + "end": 177580 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "lb.handle().eq(&_t3.handle_a0())", + "semantic_text": "lb == _t3.a0", + "referenced_vars": [ + "_t3", + "lb" + ], + "range": { + "start": 177598, + "end": 177600 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "hb.handle().eq(&_t3.handle_a1())", + "semantic_text": "hb == _t3.a1", + "referenced_vars": [ + "_t3", + "hb" + ], + "range": { + "start": 177618, + "end": 177620 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@250213:250361", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_bool_i(\n (ctx.devalue(pat.la) || ctx.devalue(pat.lb)),\n (ctx.devalue(pat.ha) && ctx.devalue(pat.hb)),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "ha", + "hb", + "la", + "lb" + ], + "referenced_action_vars": [], + "range": { + "start": 250213, + "end": 250361 + } + }, + { + "id": "effect_1", + "effect_id": "effect@250371:250393", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 250371, + "end": 250393 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0188", + "premises": [ + { + "target_id": "ha", + "label": "ha: ", + "plain_source": "upright(\"ha\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ha\") $]" + }, + { + "target_id": "hb", + "label": "hb: ", + "plain_source": "upright(\"hb\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"hb\") $]" + }, + { + "target_id": "la", + "label": "la: ", + "plain_source": "upright(\"la\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"la\") $]" + }, + { + "target_id": "lb", + "label": "lb: ", + "plain_source": "upright(\"lb\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lb\") $]" + }, + { + "target_id": "_t1", + "label": "_t1: Ecxinterval_intersect", + "plain_source": "upright(\"interval_intersect\")(upright(\"_t2\"), upright(\"_t3\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"interval_intersect\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxBoolI", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxBoolI", + "plain_source": "upright(\"_t3\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]" + } + ], + "side_conditions": [ + "upright(\"la\") == upright(\"_t2.a0\")", + "upright(\"ha\") == upright(\"_t2.a1\")", + "upright(\"lb\") == upright(\"_t3.a0\")", + "upright(\"hb\") == upright(\"_t3.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"BoolI\")(upright(\"la\") || upright(\"lb\"), upright(\"ha\") upright(\"hb\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"BoolI\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"la\") || upright(\"lb\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"ha\") upright(\"hb\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "_t1", + "label": "_t1: Ecxinterval_intersect", + "plain_source": "upright(\"interval_intersect\")(upright(\"_t2\"), upright(\"_t3\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"interval_intersect\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"BoolI\")(upright(\"la\") || upright(\"lb\"), upright(\"ha\") upright(\"hb\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"BoolI\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"la\") || upright(\"lb\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"ha\") upright(\"hb\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"ha\") \\ upright(\"hb\") \\ upright(\"la\") \\ upright(\"lb\") \\ upright(\"interval_intersect\")(upright(\"_t2\"), upright(\"_t3\")) \\ upright(\"_t2\") \\ upright(\"_t3\"), upright(\"interval_intersect\")(upright(\"_t2\"), upright(\"_t3\")) arrow.r.double upright(\"BoolI\")(upright(\"la\") || upright(\"lb\"), upright(\"ha\") upright(\"hb\"))) quad upright(\"if\") quad upright(\"la\") == upright(\"_t2.a0\") \\ upright(\"ha\") == upright(\"_t2.a1\") \\ upright(\"lb\") == upright(\"_t3.a0\") \\ upright(\"hb\") == upright(\"_t3.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ha\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"hb\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"la\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lb\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"interval_intersect\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"interval_intersect\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"BoolI\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"la\") || upright(\"lb\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"ha\") upright(\"hb\") $]) $]) quad upright(\"if\") quad upright(\"la\") == upright(\"_t2.a0\") \\ upright(\"ha\") == upright(\"_t2.a1\") \\ upright(\"lb\") == upright(\"_t3.a0\") \\ upright(\"hb\") == upright(\"_t3.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7814_5_MyTxEggccExtraction_add_rule__r0189__59c1059d3e72e953", + "display_name": "r0189", + "rule_name": "r0189", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 250407, + "line": 7814, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 250407, + "end": 250689 + }, + "pattern_range": { + "start": 250458, + "end": 250469 + }, + "action_range": { + "start": 250471, + "end": 250688 + } + }, + "nodes": [ + { + "id": "ha", + "kind": "query", + "dsl_type": "", + "label": "ha: ", + "range": { + "start": 177857, + "end": 177905 + }, + "inputs": [] + }, + { + "id": "hb", + "kind": "query", + "dsl_type": "", + "label": "hb: ", + "range": { + "start": 177910, + "end": 177958 + }, + "inputs": [] + }, + { + "id": "la", + "kind": "query", + "dsl_type": "", + "label": "la: ", + "range": { + "start": 177963, + "end": 178011 + }, + "inputs": [] + }, + { + "id": "lb", + "kind": "query", + "dsl_type": "", + "label": "lb: ", + "range": { + "start": 178016, + "end": 178064 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxBoolI", + "label": "_t2: EcxBoolI", + "range": { + "start": 178069, + "end": 178097 + }, + "inputs": [] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxBoolI", + "label": "_t3: EcxBoolI", + "range": { + "start": 178102, + "end": 178130 + }, + "inputs": [] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "Ecxinterval_union", + "label": "_t1: Ecxinterval_union", + "range": { + "start": 178135, + "end": 178182 + }, + "inputs": [ + "_t2", + "_t3" + ] + } + ], + "edges": [ + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t3", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "ha", + "hb", + "la", + "lb", + "_t1", + "_t2", + "_t3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "la.handle().eq(&_t2.handle_a0())", + "semantic_text": "la == _t2.a0", + "referenced_vars": [ + "_t2", + "la" + ], + "range": { + "start": 178435, + "end": 178437 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "ha.handle().eq(&_t2.handle_a1())", + "semantic_text": "ha == _t2.a1", + "referenced_vars": [ + "_t2", + "ha" + ], + "range": { + "start": 178455, + "end": 178457 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "lb.handle().eq(&_t3.handle_a0())", + "semantic_text": "lb == _t3.a0", + "referenced_vars": [ + "_t3", + "lb" + ], + "range": { + "start": 178475, + "end": 178477 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "hb.handle().eq(&_t3.handle_a1())", + "semantic_text": "hb == _t3.a1", + "referenced_vars": [ + "_t3", + "hb" + ], + "range": { + "start": 178495, + "end": 178497 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@250501:250649", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_bool_i(\n (ctx.devalue(pat.la) && ctx.devalue(pat.lb)),\n (ctx.devalue(pat.ha) || ctx.devalue(pat.hb)),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "ha", + "hb", + "la", + "lb" + ], + "referenced_action_vars": [], + "range": { + "start": 250501, + "end": 250649 + } + }, + { + "id": "effect_1", + "effect_id": "effect@250659:250681", + "bound_var": null, + "source_text": "ctx.union(pat._t1, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "_t1" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 250659, + "end": 250681 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0189", + "premises": [ + { + "target_id": "ha", + "label": "ha: ", + "plain_source": "upright(\"ha\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ha\") $]" + }, + { + "target_id": "hb", + "label": "hb: ", + "plain_source": "upright(\"hb\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"hb\") $]" + }, + { + "target_id": "la", + "label": "la: ", + "plain_source": "upright(\"la\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"la\") $]" + }, + { + "target_id": "lb", + "label": "lb: ", + "plain_source": "upright(\"lb\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lb\") $]" + }, + { + "target_id": "_t1", + "label": "_t1: Ecxinterval_union", + "plain_source": "upright(\"interval_union\")(upright(\"_t2\"), upright(\"_t3\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"interval_union\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxBoolI", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxBoolI", + "plain_source": "upright(\"_t3\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]" + } + ], + "side_conditions": [ + "upright(\"la\") == upright(\"_t2.a0\")", + "upright(\"ha\") == upright(\"_t2.a1\")", + "upright(\"lb\") == upright(\"_t3.a0\")", + "upright(\"hb\") == upright(\"_t3.a1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"BoolI\")(upright(\"la\") upright(\"lb\"), upright(\"ha\") || upright(\"hb\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"BoolI\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"la\") upright(\"lb\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"ha\") || upright(\"hb\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "_t1", + "label": "_t1: Ecxinterval_union", + "plain_source": "upright(\"interval_union\")(upright(\"_t2\"), upright(\"_t3\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"interval_union\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "t1", + "plain_source": "upright(\"BoolI\")(upright(\"la\") upright(\"lb\"), upright(\"ha\") || upright(\"hb\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"BoolI\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"la\") upright(\"lb\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"ha\") || upright(\"hb\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"ha\") \\ upright(\"hb\") \\ upright(\"la\") \\ upright(\"lb\") \\ upright(\"interval_union\")(upright(\"_t2\"), upright(\"_t3\")) \\ upright(\"_t2\") \\ upright(\"_t3\"), upright(\"interval_union\")(upright(\"_t2\"), upright(\"_t3\")) arrow.r.double upright(\"BoolI\")(upright(\"la\") upright(\"lb\"), upright(\"ha\") || upright(\"hb\"))) quad upright(\"if\") quad upright(\"la\") == upright(\"_t2.a0\") \\ upright(\"ha\") == upright(\"_t2.a1\") \\ upright(\"lb\") == upright(\"_t3.a0\") \\ upright(\"hb\") == upright(\"_t3.a1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ha\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"hb\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"la\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lb\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"interval_union\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"interval_union\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]) $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"BoolI\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"la\") upright(\"lb\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"ha\") || upright(\"hb\") $]) $]) quad upright(\"if\") quad upright(\"la\") == upright(\"_t2.a0\") \\ upright(\"ha\") == upright(\"_t2.a1\") \\ upright(\"lb\") == upright(\"_t3.a0\") \\ upright(\"hb\") == upright(\"_t3.a1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7821_5_MyTxEggccExtraction_add_rule__r0190__a1df7cfbbdb86d05", + "display_name": "r0190", + "rule_name": "r0190", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 250695, + "line": 7821, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 250695, + "end": 250896 + }, + "pattern_range": { + "start": 250746, + "end": 250757 + }, + "action_range": { + "start": 250759, + "end": 250895 + } + }, + "nodes": [ + { + "id": "b", + "kind": "query", + "dsl_type": "", + "label": "b: ", + "range": { + "start": 178762, + "end": 178808 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "lhs: EcxOperand", + "range": { + "start": 178813, + "end": 178848 + }, + "inputs": [] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxBoolT", + "label": "_t4: EcxBoolT", + "range": { + "start": 178853, + "end": 178881 + }, + "inputs": [] + }, + { + "id": "_t5", + "kind": "query", + "dsl_type": "Ecxkw_const", + "label": "_t5: Ecxkw_const", + "range": { + "start": 178886, + "end": 178917 + }, + "inputs": [] + }, + { + "id": "_t6", + "kind": "query", + "dsl_type": "EcxBool", + "label": "_t6: EcxBool", + "range": { + "start": 178922, + "end": 178949 + }, + "inputs": [] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxConst", + "label": "_t3: EcxConst", + "range": { + "start": 178954, + "end": 178998 + }, + "inputs": [ + "_t4", + "_t5", + "_t6" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t2: EcxPureOp", + "range": { + "start": 179003, + "end": 179036 + }, + "inputs": [ + "_t3" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t1: EcxNode", + "range": { + "start": 179041, + "end": 179072 + }, + "inputs": [ + "_t2" + ] + } + ], + "edges": [ + { + "from": "_t3", + "to": "_t4", + "kind": "operand", + "index": 0 + }, + { + "from": "_t3", + "to": "_t5", + "kind": "operand", + "index": 1 + }, + { + "from": "_t3", + "to": "_t6", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "_t3", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "b", + "lhs", + "_t1", + "_t2", + "_t3", + "_t4", + "_t5", + "_t6" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "b.handle().eq(&_t6.handle_a0())", + "semantic_text": "b == _t6.a0", + "referenced_vars": [ + "_t6", + "b" + ], + "range": { + "start": 179235, + "end": 179237 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 179255, + "end": 179257 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@250789:250850", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_bool_i(ctx.devalue(pat.b), ctx.devalue(pat.b))", + "semantic_text": null, + "referenced_pat_vars": [ + "b" + ], + "referenced_action_vars": [], + "range": { + "start": 250789, + "end": 250850 + } + }, + { + "id": "effect_1", + "effect_id": "effect@250860:250888", + "bound_var": null, + "source_text": "ctx.set_ecxival(pat.lhs, t1)", + "semantic_text": "ecxival(pat.lhs) = t1", + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 250860, + "end": 250888 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0190", + "premises": [ + { + "target_id": "b", + "label": "b: ", + "plain_source": "b", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ b $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxNode", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"_t4\"), upright(\"_t5\"), upright(\"_t6\"))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxPureOp", + "plain_source": "upright(\"PureOp\")((upright(\"Const\")(upright(\"_t4\"), upright(\"_t5\"), upright(\"_t6\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxConst", + "plain_source": "upright(\"Const\")(upright(\"_t4\"), upright(\"_t5\"), upright(\"_t6\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $]" + }, + { + "target_id": "_t4", + "label": "_t4: EcxBoolT", + "plain_source": "upright(\"BoolT\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $]" + }, + { + "target_id": "_t5", + "label": "_t5: Ecxkw_const", + "plain_source": "upright(\"kw_const\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $]" + }, + { + "target_id": "_t6", + "label": "_t6: EcxBool", + "plain_source": "upright(\"_t6\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]" + } + ], + "side_conditions": [ + "b == upright(\"_t6.a0\")", + "upright(\"lhs\") == upright(\"_t1\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "effect_1", + "plain_source": "upright(\"ecxival\")(upright(\"lhs\")) = upright(\"BoolI\")(b, b)", + "colored_source": "upright(\"ecxival\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"BoolI\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(b \\ upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"_t4\"), upright(\"_t5\"), upright(\"_t6\")))))) \\ upright(\"PureOp\")((upright(\"Const\")(upright(\"_t4\"), upright(\"_t5\"), upright(\"_t6\")))) \\ upright(\"Const\")(upright(\"_t4\"), upright(\"_t5\"), upright(\"_t6\")) \\ upright(\"BoolT\") \\ upright(\"kw_const\") \\ upright(\"_t6\"), upright(\"ecxival\")(upright(\"lhs\")) = upright(\"BoolI\")(b, b)) quad upright(\"if\") quad b == upright(\"_t6.a0\") \\ upright(\"lhs\") == upright(\"_t1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ b $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $], upright(\"ecxival\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"BoolI\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]) quad upright(\"if\") quad b == upright(\"_t6.a0\") \\ upright(\"lhs\") == upright(\"_t1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7825_5_MyTxEggccExtraction_add_rule__r0191__a54c894a64ffb546", + "display_name": "r0191", + "rule_name": "r0191", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 250902, + "line": 7825, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 250902, + "end": 251102 + }, + "pattern_range": { + "start": 250953, + "end": 250964 + }, + "action_range": { + "start": 250966, + "end": 251101 + } + }, + "nodes": [ + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "lhs: EcxOperand", + "range": { + "start": 179519, + "end": 179554 + }, + "inputs": [] + }, + { + "id": "n", + "kind": "query", + "dsl_type": "", + "label": "n: ", + "range": { + "start": 179559, + "end": 179604 + }, + "inputs": [] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxIntT", + "label": "_t4: EcxIntT", + "range": { + "start": 179609, + "end": 179636 + }, + "inputs": [] + }, + { + "id": "_t5", + "kind": "query", + "dsl_type": "Ecxkw_const", + "label": "_t5: Ecxkw_const", + "range": { + "start": 179641, + "end": 179672 + }, + "inputs": [] + }, + { + "id": "_t6", + "kind": "query", + "dsl_type": "EcxNum", + "label": "_t6: EcxNum", + "range": { + "start": 179677, + "end": 179703 + }, + "inputs": [] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxConst", + "label": "_t3: EcxConst", + "range": { + "start": 179708, + "end": 179752 + }, + "inputs": [ + "_t4", + "_t5", + "_t6" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t2: EcxPureOp", + "range": { + "start": 179757, + "end": 179790 + }, + "inputs": [ + "_t3" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t1: EcxNode", + "range": { + "start": 179795, + "end": 179826 + }, + "inputs": [ + "_t2" + ] + } + ], + "edges": [ + { + "from": "_t3", + "to": "_t4", + "kind": "operand", + "index": 0 + }, + { + "from": "_t3", + "to": "_t5", + "kind": "operand", + "index": 1 + }, + { + "from": "_t3", + "to": "_t6", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "_t3", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "lhs", + "n", + "_t1", + "_t2", + "_t3", + "_t4", + "_t5", + "_t6" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "n.handle().eq(&_t6.handle_a0())", + "semantic_text": "n == _t6.a0", + "referenced_vars": [ + "_t6", + "n" + ], + "range": { + "start": 179989, + "end": 179991 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 180009, + "end": 180011 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@250996:251056", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_int_i(ctx.devalue(pat.n), ctx.devalue(pat.n))", + "semantic_text": null, + "referenced_pat_vars": [ + "n" + ], + "referenced_action_vars": [], + "range": { + "start": 250996, + "end": 251056 + } + }, + { + "id": "effect_1", + "effect_id": "effect@251066:251094", + "bound_var": null, + "source_text": "ctx.set_ecxival(pat.lhs, t1)", + "semantic_text": "ecxival(pat.lhs) = t1", + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 251066, + "end": 251094 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0191", + "premises": [ + { + "target_id": "n", + "label": "n: ", + "plain_source": "n", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ n $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxNode", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"_t4\"), upright(\"_t5\"), upright(\"_t6\"))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxPureOp", + "plain_source": "upright(\"PureOp\")((upright(\"Const\")(upright(\"_t4\"), upright(\"_t5\"), upright(\"_t6\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxConst", + "plain_source": "upright(\"Const\")(upright(\"_t4\"), upright(\"_t5\"), upright(\"_t6\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $]" + }, + { + "target_id": "_t4", + "label": "_t4: EcxIntT", + "plain_source": "upright(\"IntT\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $]" + }, + { + "target_id": "_t5", + "label": "_t5: Ecxkw_const", + "plain_source": "upright(\"kw_const\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $]" + }, + { + "target_id": "_t6", + "label": "_t6: EcxNum", + "plain_source": "upright(\"_t6\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]" + } + ], + "side_conditions": [ + "n == upright(\"_t6.a0\")", + "upright(\"lhs\") == upright(\"_t1\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "effect_1", + "plain_source": "upright(\"ecxival\")(upright(\"lhs\")) = upright(\"IntI\")(n, n)", + "colored_source": "upright(\"ecxival\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntI\")(#text(fill: rgb(\"#5F7A8A\"))[$ n $], #text(fill: rgb(\"#5F7A8A\"))[$ n $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(n \\ upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"_t4\"), upright(\"_t5\"), upright(\"_t6\")))))) \\ upright(\"PureOp\")((upright(\"Const\")(upright(\"_t4\"), upright(\"_t5\"), upright(\"_t6\")))) \\ upright(\"Const\")(upright(\"_t4\"), upright(\"_t5\"), upright(\"_t6\")) \\ upright(\"IntT\") \\ upright(\"kw_const\") \\ upright(\"_t6\"), upright(\"ecxival\")(upright(\"lhs\")) = upright(\"IntI\")(n, n)) quad upright(\"if\") quad n == upright(\"_t6.a0\") \\ upright(\"lhs\") == upright(\"_t1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ n $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $], upright(\"ecxival\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntI\")(#text(fill: rgb(\"#5F7A8A\"))[$ n $], #text(fill: rgb(\"#5F7A8A\"))[$ n $]) $]) quad upright(\"if\") quad n == upright(\"_t6.a0\") \\ upright(\"lhs\") == upright(\"_t1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7829_5_MyTxEggccExtraction_add_rule__r0192__760b872ddb1f3b37", + "display_name": "r0192", + "rule_name": "r0192", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 251108, + "line": 7829, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 251108, + "end": 251394 + }, + "pattern_range": { + "start": 251159, + "end": 251170 + }, + "action_range": { + "start": 251172, + "end": 251393 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 180391, + "end": 180424 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 180429, + "end": 180462 + }, + "inputs": [] + }, + { + "id": "ha", + "kind": "query", + "dsl_type": "", + "label": "ha: ", + "range": { + "start": 180467, + "end": 180514 + }, + "inputs": [] + }, + { + "id": "hb", + "kind": "query", + "dsl_type": "", + "label": "hb: ", + "range": { + "start": 180519, + "end": 180566 + }, + "inputs": [] + }, + { + "id": "la", + "kind": "query", + "dsl_type": "", + "label": "la: ", + "range": { + "start": 180571, + "end": 180618 + }, + "inputs": [] + }, + { + "id": "lb", + "kind": "query", + "dsl_type": "", + "label": "lb: ", + "range": { + "start": 180623, + "end": 180670 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "lhs: EcxOperand", + "range": { + "start": 180675, + "end": 180710 + }, + "inputs": [] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxBoolT", + "label": "_t4: EcxBoolT", + "range": { + "start": 180715, + "end": 180743 + }, + "inputs": [] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "Ecxblt", + "label": "_t3: Ecxblt", + "range": { + "start": 180748, + "end": 180786 + }, + "inputs": [ + "_t4", + "a", + "b" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t2: EcxPureOp", + "range": { + "start": 180791, + "end": 180824 + }, + "inputs": [ + "_t3" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t1: EcxNode", + "range": { + "start": 180829, + "end": 180860 + }, + "inputs": [ + "_t2" + ] + }, + { + "id": "_t5", + "kind": "query", + "dsl_type": "EcxIntI", + "label": "_t5: EcxIntI", + "range": { + "start": 180865, + "end": 180892 + }, + "inputs": [] + }, + { + "id": "_f6", + "kind": "query", + "dsl_type": "Ecxival", + "label": "_f6: Ecxival", + "range": { + "start": 180897, + "end": 180926 + }, + "inputs": [ + "a" + ] + }, + { + "id": "_t7", + "kind": "query", + "dsl_type": "EcxIntI", + "label": "_t7: EcxIntI", + "range": { + "start": 180931, + "end": 180958 + }, + "inputs": [] + }, + { + "id": "_f8", + "kind": "query", + "dsl_type": "Ecxival", + "label": "_f8: Ecxival", + "range": { + "start": 180963, + "end": 180992 + }, + "inputs": [ + "b" + ] + } + ], + "edges": [ + { + "from": "_t3", + "to": "_t4", + "kind": "operand", + "index": 0 + }, + { + "from": "_t3", + "to": "a", + "kind": "operand", + "index": 1 + }, + { + "from": "_t3", + "to": "b", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "_t3", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_f6", + "to": "a", + "kind": "operand", + "index": 0 + }, + { + "from": "_f8", + "to": "b", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "a", + "b", + "ha", + "hb", + "la", + "lb", + "lhs", + "_t1", + "_t2", + "_t3", + "_t4", + "_t5", + "_f6", + "_t7", + "_f8" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 181427, + "end": 181429 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "la.handle().eq(&_t5.handle_a0())", + "semantic_text": "la == _t5.a0", + "referenced_vars": [ + "_t5", + "la" + ], + "range": { + "start": 181443, + "end": 181445 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "ha.handle().eq(&_t5.handle_a1())", + "semantic_text": "ha == _t5.a1", + "referenced_vars": [ + "_t5", + "ha" + ], + "range": { + "start": 181459, + "end": 181461 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "_t5.handle().eq(&_f6.handle())", + "semantic_text": "_t5 == _f6", + "referenced_vars": [ + "_f6", + "_t5" + ], + "range": { + "start": 181475, + "end": 181477 + } + }, + { + "id": "constraint_4", + "source_text": "c4", + "resolved_text": "lb.handle().eq(&_t7.handle_a0())", + "semantic_text": "lb == _t7.a0", + "referenced_vars": [ + "_t7", + "lb" + ], + "range": { + "start": 181491, + "end": 181493 + } + }, + { + "id": "constraint_5", + "source_text": "c5", + "resolved_text": "hb.handle().eq(&_t7.handle_a1())", + "semantic_text": "hb == _t7.a1", + "referenced_vars": [ + "_t7", + "hb" + ], + "range": { + "start": 181507, + "end": 181509 + } + }, + { + "id": "constraint_6", + "source_text": "c6", + "resolved_text": "_t7.handle().eq(&_f8.handle())", + "semantic_text": "_t7 == _f8", + "referenced_vars": [ + "_f8", + "_t7" + ], + "range": { + "start": 181523, + "end": 181525 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@251202:251348", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_bool_i(\n (ctx.devalue(pat.ha) < ctx.devalue(pat.lb)),\n (ctx.devalue(pat.la) < ctx.devalue(pat.hb)),\n )", + "semantic_text": null, + "referenced_pat_vars": [ + "ha", + "hb", + "la", + "lb" + ], + "referenced_action_vars": [], + "range": { + "start": 251202, + "end": 251348 + } + }, + { + "id": "effect_1", + "effect_id": "effect@251358:251386", + "bound_var": null, + "source_text": "ctx.set_ecxival(pat.lhs, t1)", + "semantic_text": "ecxival(pat.lhs) = t1", + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 251358, + "end": 251386 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0192", + "premises": [ + { + "target_id": "ha", + "label": "ha: ", + "plain_source": "upright(\"ha\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ha\") $]" + }, + { + "target_id": "hb", + "label": "hb: ", + "plain_source": "upright(\"hb\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"hb\") $]" + }, + { + "target_id": "la", + "label": "la: ", + "plain_source": "upright(\"la\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"la\") $]" + }, + { + "target_id": "lb", + "label": "lb: ", + "plain_source": "upright(\"lb\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lb\") $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxNode", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"blt\")(upright(\"BoolT\"), a, b)))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $])) $])) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxPureOp", + "plain_source": "upright(\"PureOp\")((upright(\"blt\")(upright(\"BoolT\"), a, b)))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $])) $]" + }, + { + "target_id": "_t3", + "label": "_t3: Ecxblt", + "plain_source": "upright(\"blt\")(upright(\"BoolT\"), a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + }, + { + "target_id": "_t4", + "label": "_t4: EcxBoolT", + "plain_source": "upright(\"BoolT\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $]" + }, + { + "target_id": "_t5", + "label": "_t5: EcxIntI", + "plain_source": "upright(\"_t5\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $]" + }, + { + "target_id": "_f6", + "label": "_f6: Ecxival", + "plain_source": "upright(\"Ecxival\")(a)", + "colored_source": "upright(\"Ecxival\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $])" + }, + { + "target_id": "_t7", + "label": "_t7: EcxIntI", + "plain_source": "upright(\"_t7\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $]" + }, + { + "target_id": "_f8", + "label": "_f8: Ecxival", + "plain_source": "upright(\"Ecxival\")(b)", + "colored_source": "upright(\"Ecxival\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $])" + } + ], + "side_conditions": [ + "upright(\"lhs\") == upright(\"_t1\")", + "upright(\"la\") == upright(\"_t5.a0\")", + "upright(\"ha\") == upright(\"_t5.a1\")", + "upright(\"_t5\") == upright(\"_f6\")", + "upright(\"lb\") == upright(\"_t7.a0\")", + "upright(\"hb\") == upright(\"_t7.a1\")", + "upright(\"_t7\") == upright(\"_f8\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "effect_1", + "plain_source": "upright(\"ecxival\")(upright(\"lhs\")) = upright(\"BoolI\")(upright(\"ha\") < upright(\"lb\"), upright(\"la\") < upright(\"hb\"))", + "colored_source": "upright(\"ecxival\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"BoolI\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ha\") < upright(\"lb\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"la\") < upright(\"hb\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"ha\") \\ upright(\"hb\") \\ upright(\"la\") \\ upright(\"lb\") \\ upright(\"Node\")((upright(\"PureOp\")((upright(\"blt\")(upright(\"BoolT\"), a, b))))) \\ upright(\"PureOp\")((upright(\"blt\")(upright(\"BoolT\"), a, b))) \\ upright(\"blt\")(upright(\"BoolT\"), a, b) \\ upright(\"BoolT\") \\ upright(\"_t5\") \\ upright(\"Ecxival\")(a) \\ upright(\"_t7\") \\ upright(\"Ecxival\")(b), upright(\"ecxival\")(upright(\"lhs\")) = upright(\"BoolI\")(upright(\"ha\") < upright(\"lb\"), upright(\"la\") < upright(\"hb\"))) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\") \\ upright(\"la\") == upright(\"_t5.a0\") \\ upright(\"ha\") == upright(\"_t5.a1\") \\ upright(\"_t5\") == upright(\"_f6\") \\ upright(\"lb\") == upright(\"_t7.a0\") \\ upright(\"hb\") == upright(\"_t7.a1\") \\ upright(\"_t7\") == upright(\"_f8\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ha\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"hb\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"la\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lb\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"blt\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"BoolT\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $] \\ upright(\"Ecxival\")(#text(fill: rgb(\"#5F7A8A\"))[$ a $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t7\") $] \\ upright(\"Ecxival\")(#text(fill: rgb(\"#5F7A8A\"))[$ b $]), upright(\"ecxival\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"BoolI\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"ha\") < upright(\"lb\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"la\") < upright(\"hb\") $]) $]) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\") \\ upright(\"la\") == upright(\"_t5.a0\") \\ upright(\"ha\") == upright(\"_t5.a1\") \\ upright(\"_t5\") == upright(\"_f6\") \\ upright(\"lb\") == upright(\"_t7.a0\") \\ upright(\"hb\") == upright(\"_t7.a1\") \\ upright(\"_t7\") == upright(\"_f8\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7836_5_MyTxEggccExtraction_add_rule__r0193__fc9d33c874e81f1c", + "display_name": "r0193", + "rule_name": "r0193", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 251400, + "line": 7836, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 251400, + "end": 251596 + }, + "pattern_range": { + "start": 251451, + "end": 251462 + }, + "action_range": { + "start": 251464, + "end": 251595 + } + }, + "nodes": [ + { + "id": "elseival", + "kind": "query_leaf", + "dsl_type": "EcxInterval", + "label": "elseival: EcxInterval", + "range": { + "start": 182188, + "end": 182229 + }, + "inputs": [] + }, + { + "id": "elses", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "elses: EcxVecOperandBase", + "range": { + "start": 182234, + "end": 182278 + }, + "inputs": [] + }, + { + "id": "i", + "kind": "query", + "dsl_type": "", + "label": "i: ", + "range": { + "start": 182283, + "end": 182328 + }, + "inputs": [] + }, + { + "id": "ins", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "ins: EcxVecOperand", + "range": { + "start": 182333, + "end": 182371 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "lhs: EcxOperand", + "range": { + "start": 182376, + "end": 182411 + }, + "inputs": [] + }, + { + "id": "outs", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperandBase", + "label": "outs: EcxVecVecOperandBase", + "range": { + "start": 182416, + "end": 182462 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 182467, + "end": 182503 + }, + "inputs": [] + }, + { + "id": "thenival", + "kind": "query_leaf", + "dsl_type": "EcxInterval", + "label": "thenival: EcxInterval", + "range": { + "start": 182508, + "end": 182549 + }, + "inputs": [] + }, + { + "id": "thens", + "kind": "query_leaf", + "dsl_type": "EcxVecOperandBase", + "label": "thens: EcxVecOperandBase", + "range": { + "start": 182554, + "end": 182598 + }, + "inputs": [] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t3: EcxVVO", + "range": { + "start": 182603, + "end": 182634 + }, + "inputs": [ + "outs" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxGamma", + "label": "_t2: EcxGamma", + "range": { + "start": 182639, + "end": 182684 + }, + "inputs": [ + "pred", + "ins", + "_t3" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxProject", + "label": "_t1: EcxProject", + "range": { + "start": 182689, + "end": 182723 + }, + "inputs": [ + "_t2" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t4: EcxVO", + "range": { + "start": 182728, + "end": 182759 + }, + "inputs": [ + "thens" + ] + }, + { + "id": "_t6", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t6: EcxVVO", + "range": { + "start": 182764, + "end": 182795 + }, + "inputs": [ + "outs" + ] + }, + { + "id": "_t5", + "kind": "query", + "dsl_type": "EcxVecVecOperand_get", + "label": "_t5: EcxVecVecOperand_get", + "range": { + "start": 182800, + "end": 182844 + }, + "inputs": [ + "_t6" + ] + }, + { + "id": "_t7", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t7: EcxVO", + "range": { + "start": 182849, + "end": 182880 + }, + "inputs": [ + "elses" + ] + }, + { + "id": "_t9", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t9: EcxVVO", + "range": { + "start": 182885, + "end": 182916 + }, + "inputs": [ + "outs" + ] + }, + { + "id": "_t8", + "kind": "query", + "dsl_type": "EcxVecVecOperand_get", + "label": "_t8: EcxVecVecOperand_get", + "range": { + "start": 182921, + "end": 182965 + }, + "inputs": [ + "_t9" + ] + }, + { + "id": "_t12", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t12: EcxVO", + "range": { + "start": 182970, + "end": 183002 + }, + "inputs": [ + "thens" + ] + }, + { + "id": "_t11", + "kind": "query", + "dsl_type": "EcxVecOperand_get", + "label": "_t11: EcxVecOperand_get", + "range": { + "start": 183007, + "end": 183050 + }, + "inputs": [ + "_t12" + ] + }, + { + "id": "_f10", + "kind": "query", + "dsl_type": "Ecxival", + "label": "_f10: Ecxival", + "range": { + "start": 183055, + "end": 183088 + }, + "inputs": [ + "_t11" + ] + }, + { + "id": "_t15", + "kind": "query", + "dsl_type": "EcxVO", + "label": "_t15: EcxVO", + "range": { + "start": 183093, + "end": 183125 + }, + "inputs": [ + "elses" + ] + }, + { + "id": "_t14", + "kind": "query", + "dsl_type": "EcxVecOperand_get", + "label": "_t14: EcxVecOperand_get", + "range": { + "start": 183130, + "end": 183173 + }, + "inputs": [ + "_t15" + ] + }, + { + "id": "_f13", + "kind": "query", + "dsl_type": "Ecxival", + "label": "_f13: Ecxival", + "range": { + "start": 183178, + "end": 183211 + }, + "inputs": [ + "_t14" + ] + } + ], + "edges": [ + { + "from": "_t3", + "to": "outs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "ins", + "kind": "operand", + "index": 1 + }, + { + "from": "_t2", + "to": "_t3", + "kind": "operand", + "index": 2 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t4", + "to": "thens", + "kind": "operand", + "index": 0 + }, + { + "from": "_t6", + "to": "outs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t5", + "to": "_t6", + "kind": "operand", + "index": 0 + }, + { + "from": "_t7", + "to": "elses", + "kind": "operand", + "index": 0 + }, + { + "from": "_t9", + "to": "outs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t8", + "to": "_t9", + "kind": "operand", + "index": 0 + }, + { + "from": "_t12", + "to": "thens", + "kind": "operand", + "index": 0 + }, + { + "from": "_t11", + "to": "_t12", + "kind": "operand", + "index": 0 + }, + { + "from": "_f10", + "to": "_t11", + "kind": "operand", + "index": 0 + }, + { + "from": "_t15", + "to": "elses", + "kind": "operand", + "index": 0 + }, + { + "from": "_t14", + "to": "_t15", + "kind": "operand", + "index": 0 + }, + { + "from": "_f13", + "to": "_t14", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "elseival", + "elses", + "i", + "ins", + "lhs", + "outs", + "pred", + "thenival", + "thens", + "_t1", + "_t2", + "_t3", + "_t4", + "_t5", + "_t6", + "_t7", + "_t8", + "_t9", + "_f10", + "_t11", + "_t12", + "_f13", + "_t14", + "_t15" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "i.handle().eq(&_t1.handle_a0())", + "semantic_text": "i == _t1.a0", + "referenced_vars": [ + "_t1", + "i" + ], + "range": { + "start": 183867, + "end": 183869 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 183883, + "end": 183885 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "_t5.handle_a1().eq(&(1_i64))", + "semantic_text": "_t5.a1 == 1", + "referenced_vars": [ + "_t5" + ], + "range": { + "start": 183899, + "end": 183901 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "_t4.handle().eq(&_t5.handle())", + "semantic_text": "_t4 == _t5", + "referenced_vars": [ + "_t4", + "_t5" + ], + "range": { + "start": 183915, + "end": 183917 + } + }, + { + "id": "constraint_4", + "source_text": "c4", + "resolved_text": "_t8.handle_a1().eq(&(0_i64))", + "semantic_text": "_t8.a1 == 0", + "referenced_vars": [ + "_t8" + ], + "range": { + "start": 183931, + "end": 183933 + } + }, + { + "id": "constraint_5", + "source_text": "c5", + "resolved_text": "_t7.handle().eq(&_t8.handle())", + "semantic_text": "_t7 == _t8", + "referenced_vars": [ + "_t7", + "_t8" + ], + "range": { + "start": 183947, + "end": 183949 + } + }, + { + "id": "constraint_6", + "source_text": "c6", + "resolved_text": "i.handle().eq(&_t11.handle_a1())", + "semantic_text": "i == _t11.a1", + "referenced_vars": [ + "_t11", + "i" + ], + "range": { + "start": 183963, + "end": 183965 + } + }, + { + "id": "constraint_7", + "source_text": "c7", + "resolved_text": "thenival.handle().eq(&_f10.handle())", + "semantic_text": "thenival == _f10", + "referenced_vars": [ + "_f10", + "thenival" + ], + "range": { + "start": 183979, + "end": 183981 + } + }, + { + "id": "constraint_8", + "source_text": "c8", + "resolved_text": "i.handle().eq(&_t14.handle_a1())", + "semantic_text": "i == _t14.a1", + "referenced_vars": [ + "_t14", + "i" + ], + "range": { + "start": 183995, + "end": 183997 + } + }, + { + "id": "constraint_9", + "source_text": "c9", + "resolved_text": "elseival.handle().eq(&_f13.handle())", + "semantic_text": "elseival == _f13", + "referenced_vars": [ + "_f13", + "elseival" + ], + "range": { + "start": 184011, + "end": 184013 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@251494:251550", + "bound_var": "t1", + "source_text": "ctx.insert_ecxinterval_union(pat.thenival, pat.elseival)", + "semantic_text": null, + "referenced_pat_vars": [ + "elseival", + "thenival" + ], + "referenced_action_vars": [], + "range": { + "start": 251494, + "end": 251550 + } + }, + { + "id": "effect_1", + "effect_id": "effect@251560:251588", + "bound_var": null, + "source_text": "ctx.set_ecxival(pat.lhs, t1)", + "semantic_text": "ecxival(pat.lhs) = t1", + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 251560, + "end": 251588 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0193", + "premises": [ + { + "target_id": "i", + "label": "i: ", + "plain_source": "i", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ i $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxProject", + "plain_source": "upright(\"_t1\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxGamma", + "plain_source": "upright(\"Gamma\")(upright(\"pred\"), upright(\"ins\"), (upright(\"VVO\")(upright(\"outs\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ins\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outs\") $]) $])) $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"outs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outs\") $]) $]" + }, + { + "target_id": "_t4", + "label": "_t4: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"thens\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"thens\") $]) $]" + }, + { + "target_id": "_t5", + "label": "_t5: EcxVecVecOperand_get", + "plain_source": "upright(\"_t5\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $]" + }, + { + "target_id": "_t6", + "label": "_t6: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"outs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outs\") $]) $]" + }, + { + "target_id": "_t7", + "label": "_t7: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"elses\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"elses\") $]) $]" + }, + { + "target_id": "_t8", + "label": "_t8: EcxVecVecOperand_get", + "plain_source": "upright(\"_t8\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t8\") $]" + }, + { + "target_id": "_t9", + "label": "_t9: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"outs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outs\") $]) $]" + }, + { + "target_id": "_f10", + "label": "_f10: Ecxival", + "plain_source": "upright(\"Ecxival\")(upright(\"_t11\"))", + "colored_source": "upright(\"Ecxival\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $])" + }, + { + "target_id": "_t11", + "label": "_t11: EcxVecOperand_get", + "plain_source": "upright(\"_t11\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]" + }, + { + "target_id": "_t12", + "label": "_t12: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"thens\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"thens\") $]) $]" + }, + { + "target_id": "_f13", + "label": "_f13: Ecxival", + "plain_source": "upright(\"Ecxival\")(upright(\"_t14\"))", + "colored_source": "upright(\"Ecxival\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t14\") $])" + }, + { + "target_id": "_t14", + "label": "_t14: EcxVecOperand_get", + "plain_source": "upright(\"_t14\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t14\") $]" + }, + { + "target_id": "_t15", + "label": "_t15: EcxVO", + "plain_source": "upright(\"VO\")(upright(\"elses\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"elses\") $]) $]" + } + ], + "side_conditions": [ + "i == upright(\"_t1.a0\")", + "upright(\"lhs\") == upright(\"_t1\")", + "upright(\"_t5.a1\") == 1", + "upright(\"_t4\") == upright(\"_t5\")", + "upright(\"_t8.a1\") == 0", + "upright(\"_t7\") == upright(\"_t8\")", + "i == upright(\"_t11.a1\")", + "upright(\"thenival\") == upright(\"_f10\")", + "i == upright(\"_t14.a1\")", + "upright(\"elseival\") == upright(\"_f13\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "effect_1", + "plain_source": "upright(\"ecxival\")(upright(\"lhs\")) = upright(\"EcxintervalUnion\")(upright(\"thenival\"), upright(\"elseival\"))", + "colored_source": "upright(\"ecxival\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = upright(\"EcxintervalUnion\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"thenival\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"elseival\") $])" + } + } + ], + "formula_source": { + "plain": "frac(i \\ upright(\"_t1\") \\ upright(\"Gamma\")(upright(\"pred\"), upright(\"ins\"), (upright(\"VVO\")(upright(\"outs\")))) \\ upright(\"VVO\")(upright(\"outs\")) \\ upright(\"VO\")(upright(\"thens\")) \\ upright(\"_t5\") \\ upright(\"VVO\")(upright(\"outs\")) \\ upright(\"VO\")(upright(\"elses\")) \\ upright(\"_t8\") \\ upright(\"VVO\")(upright(\"outs\")) \\ upright(\"Ecxival\")(upright(\"_t11\")) \\ upright(\"_t11\") \\ upright(\"VO\")(upright(\"thens\")) \\ upright(\"Ecxival\")(upright(\"_t14\")) \\ upright(\"_t14\") \\ upright(\"VO\")(upright(\"elses\")), upright(\"ecxival\")(upright(\"lhs\")) = upright(\"EcxintervalUnion\")(upright(\"thenival\"), upright(\"elseival\"))) quad upright(\"if\") quad i == upright(\"_t1.a0\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"_t5.a1\") == 1 \\ upright(\"_t4\") == upright(\"_t5\") \\ upright(\"_t8.a1\") == 0 \\ upright(\"_t7\") == upright(\"_t8\") \\ i == upright(\"_t11.a1\") \\ upright(\"thenival\") == upright(\"_f10\") \\ i == upright(\"_t14.a1\") \\ upright(\"elseival\") == upright(\"_f13\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ i $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t1\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"ins\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outs\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"thens\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"elses\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t8\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outs\") $]) $] \\ upright(\"Ecxival\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"thens\") $]) $] \\ upright(\"Ecxival\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t14\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t14\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"elses\") $]) $], upright(\"ecxival\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) = upright(\"EcxintervalUnion\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"thenival\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"elseival\") $])) quad upright(\"if\") quad i == upright(\"_t1.a0\") \\ upright(\"lhs\") == upright(\"_t1\") \\ upright(\"_t5.a1\") == 1 \\ upright(\"_t4\") == upright(\"_t5\") \\ upright(\"_t8.a1\") == 0 \\ upright(\"_t7\") == upright(\"_t8\") \\ i == upright(\"_t11.a1\") \\ upright(\"thenival\") == upright(\"_f10\") \\ i == upright(\"_t14.a1\") \\ upright(\"elseival\") == upright(\"_f13\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7840_5_MyTxEggccExtraction_add_rule__r0194__fcfd6b295a073e28", + "display_name": "r0194", + "rule_name": "r0194", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 251602, + "line": 7840, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 251602, + "end": 251955 + }, + "pattern_range": { + "start": 251653, + "end": 251664 + }, + "action_range": { + "start": 251666, + "end": 251954 + } + }, + "nodes": [ + { + "id": "gamma", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "gamma: EcxBody", + "range": { + "start": 184309, + "end": 184343 + }, + "inputs": [] + }, + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 184348, + "end": 184389 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperandBase", + "label": "outputs: EcxVecVecOperandBase", + "range": { + "start": 184394, + "end": 184443 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 184448, + "end": 184484 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t2: EcxVVO", + "range": { + "start": 184489, + "end": 184523 + }, + "inputs": [ + "outputs" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxGamma", + "label": "_t1: EcxGamma", + "range": { + "start": 184528, + "end": 184576 + }, + "inputs": [ + "pred", + "inputs", + "_t2" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxBoolI", + "label": "_t3: EcxBoolI", + "range": { + "start": 184581, + "end": 184609 + }, + "inputs": [] + }, + { + "id": "_f4", + "kind": "query", + "dsl_type": "Ecxival", + "label": "_f4: Ecxival", + "range": { + "start": 184614, + "end": 184646 + }, + "inputs": [ + "pred" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "outputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 2 + }, + { + "from": "_f4", + "to": "pred", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "gamma", + "inputs", + "outputs", + "pred", + "_t1", + "_t2", + "_t3", + "_f4" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "gamma.handle().eq(&_t1.handle())", + "semantic_text": "gamma == _t1", + "referenced_vars": [ + "_t1", + "gamma" + ], + "range": { + "start": 184906, + "end": 184908 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "_t3.handle_a0().eq(&(true))", + "semantic_text": "_t3.a0 == true", + "referenced_vars": [ + "_t3" + ], + "range": { + "start": 184926, + "end": 184928 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "_t3.handle_a1().eq(&(true))", + "semantic_text": "_t3.a1 == true", + "referenced_vars": [ + "_t3" + ], + "range": { + "start": 184946, + "end": 184948 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "_t3.handle().eq(&_f4.handle())", + "semantic_text": "_t3 == _f4", + "referenced_vars": [ + "_f4", + "_t3" + ], + "range": { + "start": 184966, + "end": 184968 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@251696:251727", + "bound_var": "t4", + "source_text": "ctx.insert_ecx_vvo(pat.outputs)", + "semantic_text": null, + "referenced_pat_vars": [ + "outputs" + ], + "referenced_action_vars": [], + "range": { + "start": 251696, + "end": 251727 + } + }, + { + "id": "effect_1", + "effect_id": "effect@251746:251791", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_vec_vec_operand_get(t4, 1_i64)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t4" + ], + "range": { + "start": 251746, + "end": 251791 + } + }, + { + "id": "effect_2", + "effect_id": "effect@251810:251862", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_vec_operand_all(t3, pat.inputs)", + "semantic_text": null, + "referenced_pat_vars": [ + "inputs" + ], + "referenced_action_vars": [ + "t3" + ], + "range": { + "start": 251810, + "end": 251862 + } + }, + { + "id": "effect_3", + "effect_id": "effect@251881:251913", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_operand_group(t2)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 251881, + "end": 251913 + } + }, + { + "id": "effect_4", + "effect_id": "effect@251923:251947", + "bound_var": null, + "source_text": "ctx.union(pat.gamma, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "gamma" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 251923, + "end": 251947 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0194", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxGamma", + "plain_source": "upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), (upright(\"VVO\")(upright(\"outputs\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxBoolI", + "plain_source": "upright(\"_t3\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]" + }, + { + "target_id": "_f4", + "label": "_f4: Ecxival", + "plain_source": "upright(\"Ecxival\")(upright(\"pred\"))", + "colored_source": "upright(\"Ecxival\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $])" + } + ], + "side_conditions": [ + "upright(\"gamma\") == upright(\"_t1\")", + "upright(\"_t3.a0\") == upright(\"true\")", + "upright(\"_t3.a1\") == upright(\"true\")", + "upright(\"_t3\") == upright(\"_f4\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t4", + "plain_source": "upright(\"EcxVvo\")(upright(\"outputs\"))", + "colored_source": "upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $])" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(upright(\"outputs\")), 1)", + "colored_source": "upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 1 $])" + }, + { + "target_id": "effect:effect_2", + "label": "t2", + "plain_source": "upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(upright(\"outputs\")), 1), upright(\"inputs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $]" + }, + { + "target_id": "effect:effect_3", + "label": "t1", + "plain_source": "upright(\"OperandGroup\")((upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(upright(\"outputs\")), 1), upright(\"inputs\"))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_4", + "from": { + "target_id": "gamma", + "label": "gamma: EcxBody", + "plain_source": "upright(\"gamma\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"gamma\") $]" + }, + "to": { + "target_id": "effect:effect_3", + "label": "t1", + "plain_source": "upright(\"OperandGroup\")((upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(upright(\"outputs\")), 1), upright(\"inputs\"))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), (upright(\"VVO\")(upright(\"outputs\")))) \\ upright(\"VVO\")(upright(\"outputs\")) \\ upright(\"_t3\") \\ upright(\"Ecxival\")(upright(\"pred\")), upright(\"gamma\") arrow.r.double upright(\"OperandGroup\")((upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(upright(\"outputs\")), 1), upright(\"inputs\"))))) quad upright(\"if\") quad upright(\"gamma\") == upright(\"_t1\") \\ upright(\"_t3.a0\") == upright(\"true\") \\ upright(\"_t3.a1\") == upright(\"true\") \\ upright(\"_t3\") == upright(\"_f4\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $] \\ upright(\"Ecxival\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"gamma\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 1 $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $])) $]) quad upright(\"if\") quad upright(\"gamma\") == upright(\"_t1\") \\ upright(\"_t3.a0\") == upright(\"true\") \\ upright(\"_t3.a1\") == upright(\"true\") \\ upright(\"_t3\") == upright(\"_f4\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7847_5_MyTxEggccExtraction_add_rule__r0195__0837cceed1e51636", + "display_name": "r0195", + "rule_name": "r0195", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 251961, + "line": 7847, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 251961, + "end": 252314 + }, + "pattern_range": { + "start": 252012, + "end": 252023 + }, + "action_range": { + "start": 252025, + "end": 252313 + } + }, + "nodes": [ + { + "id": "gamma", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "gamma: EcxBody", + "range": { + "start": 185264, + "end": 185298 + }, + "inputs": [] + }, + { + "id": "inputs", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "inputs: EcxVecOperand", + "range": { + "start": 185303, + "end": 185344 + }, + "inputs": [] + }, + { + "id": "outputs", + "kind": "query_leaf", + "dsl_type": "EcxVecVecOperandBase", + "label": "outputs: EcxVecVecOperandBase", + "range": { + "start": 185349, + "end": 185398 + }, + "inputs": [] + }, + { + "id": "pred", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "pred: EcxOperand", + "range": { + "start": 185403, + "end": 185439 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxVVO", + "label": "_t2: EcxVVO", + "range": { + "start": 185444, + "end": 185478 + }, + "inputs": [ + "outputs" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxGamma", + "label": "_t1: EcxGamma", + "range": { + "start": 185483, + "end": 185531 + }, + "inputs": [ + "pred", + "inputs", + "_t2" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxBoolI", + "label": "_t3: EcxBoolI", + "range": { + "start": 185536, + "end": 185564 + }, + "inputs": [] + }, + { + "id": "_f4", + "kind": "query", + "dsl_type": "Ecxival", + "label": "_f4: Ecxival", + "range": { + "start": 185569, + "end": 185601 + }, + "inputs": [ + "pred" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "outputs", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "pred", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "inputs", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 2 + }, + { + "from": "_f4", + "to": "pred", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "gamma", + "inputs", + "outputs", + "pred", + "_t1", + "_t2", + "_t3", + "_f4" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "gamma.handle().eq(&_t1.handle())", + "semantic_text": "gamma == _t1", + "referenced_vars": [ + "_t1", + "gamma" + ], + "range": { + "start": 185863, + "end": 185865 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "_t3.handle_a0().eq(&(false))", + "semantic_text": "_t3.a0 == false", + "referenced_vars": [ + "_t3" + ], + "range": { + "start": 185883, + "end": 185885 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "_t3.handle_a1().eq(&(false))", + "semantic_text": "_t3.a1 == false", + "referenced_vars": [ + "_t3" + ], + "range": { + "start": 185903, + "end": 185905 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "_t3.handle().eq(&_f4.handle())", + "semantic_text": "_t3 == _f4", + "referenced_vars": [ + "_f4", + "_t3" + ], + "range": { + "start": 185923, + "end": 185925 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@252055:252086", + "bound_var": "t4", + "source_text": "ctx.insert_ecx_vvo(pat.outputs)", + "semantic_text": null, + "referenced_pat_vars": [ + "outputs" + ], + "referenced_action_vars": [], + "range": { + "start": 252055, + "end": 252086 + } + }, + { + "id": "effect_1", + "effect_id": "effect@252105:252150", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_vec_vec_operand_get(t4, 0_i64)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t4" + ], + "range": { + "start": 252105, + "end": 252150 + } + }, + { + "id": "effect_2", + "effect_id": "effect@252169:252221", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_vec_operand_all(t3, pat.inputs)", + "semantic_text": null, + "referenced_pat_vars": [ + "inputs" + ], + "referenced_action_vars": [ + "t3" + ], + "range": { + "start": 252169, + "end": 252221 + } + }, + { + "id": "effect_3", + "effect_id": "effect@252240:252272", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_operand_group(t2)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 252240, + "end": 252272 + } + }, + { + "id": "effect_4", + "effect_id": "effect@252282:252306", + "bound_var": null, + "source_text": "ctx.union(pat.gamma, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "gamma" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 252282, + "end": 252306 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0195", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: EcxGamma", + "plain_source": "upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), (upright(\"VVO\")(upright(\"outputs\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxVVO", + "plain_source": "upright(\"VVO\")(upright(\"outputs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxBoolI", + "plain_source": "upright(\"_t3\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]" + }, + { + "target_id": "_f4", + "label": "_f4: Ecxival", + "plain_source": "upright(\"Ecxival\")(upright(\"pred\"))", + "colored_source": "upright(\"Ecxival\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $])" + } + ], + "side_conditions": [ + "upright(\"gamma\") == upright(\"_t1\")", + "upright(\"_t3.a0\") == upright(\"false\")", + "upright(\"_t3.a1\") == upright(\"false\")", + "upright(\"_t3\") == upright(\"_f4\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t4", + "plain_source": "upright(\"EcxVvo\")(upright(\"outputs\"))", + "colored_source": "upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $])" + }, + { + "target_id": "effect:effect_1", + "label": "t3", + "plain_source": "upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(upright(\"outputs\")), 0)", + "colored_source": "upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 0 $])" + }, + { + "target_id": "effect:effect_2", + "label": "t2", + "plain_source": "upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(upright(\"outputs\")), 0), upright(\"inputs\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $]" + }, + { + "target_id": "effect:effect_3", + "label": "t1", + "plain_source": "upright(\"OperandGroup\")((upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(upright(\"outputs\")), 0), upright(\"inputs\"))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_4", + "from": { + "target_id": "gamma", + "label": "gamma: EcxBody", + "plain_source": "upright(\"gamma\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"gamma\") $]" + }, + "to": { + "target_id": "effect:effect_3", + "label": "t1", + "plain_source": "upright(\"OperandGroup\")((upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(upright(\"outputs\")), 0), upright(\"inputs\"))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"Gamma\")(upright(\"pred\"), upright(\"inputs\"), (upright(\"VVO\")(upright(\"outputs\")))) \\ upright(\"VVO\")(upright(\"outputs\")) \\ upright(\"_t3\") \\ upright(\"Ecxival\")(upright(\"pred\")), upright(\"gamma\") arrow.r.double upright(\"OperandGroup\")((upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(upright(\"outputs\")), 0), upright(\"inputs\"))))) quad upright(\"if\") quad upright(\"gamma\") == upright(\"_t1\") \\ upright(\"_t3.a0\") == upright(\"false\") \\ upright(\"_t3.a1\") == upright(\"false\") \\ upright(\"_t3\") == upright(\"_f4\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Gamma\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"VVO\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $] \\ upright(\"Ecxival\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"pred\") $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"gamma\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(upright(\"EcxVecVecOperandGet\")(upright(\"EcxVvo\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"outputs\") $]), #text(fill: rgb(\"#B86A5B\"))[$ 0 $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inputs\") $]) $])) $]) quad upright(\"if\") quad upright(\"gamma\") == upright(\"_t1\") \\ upright(\"_t3.a0\") == upright(\"false\") \\ upright(\"_t3.a1\") == upright(\"false\") \\ upright(\"_t3\") == upright(\"_f4\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7854_5_MyTxEggccExtraction_add_rule__r0196__7fe8d638759bcf33", + "display_name": "r0196", + "rule_name": "r0196", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 252320, + "line": 7854, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 252320, + "end": 252567 + }, + "pattern_range": { + "start": 252371, + "end": 252382 + }, + "action_range": { + "start": 252384, + "end": 252566 + } + }, + "nodes": [ + { + "id": "args", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "args: EcxVecOperand", + "range": { + "start": 186286, + "end": 186325 + }, + "inputs": [] + }, + { + "id": "body", + "kind": "query_leaf", + "dsl_type": "EcxVecOperand", + "label": "body: EcxVecOperand", + "range": { + "start": 186330, + "end": 186369 + }, + "inputs": [] + }, + { + "id": "input_types", + "kind": "query_leaf", + "dsl_type": "EcxFuncSigs", + "label": "input_types: EcxFuncSigs", + "range": { + "start": 186374, + "end": 186418 + }, + "inputs": [] + }, + { + "id": "name", + "kind": "query", + "dsl_type": "", + "label": "name: ", + "range": { + "start": 186423, + "end": 186477 + }, + "inputs": [] + }, + { + "id": "num", + "kind": "query", + "dsl_type": "", + "label": "num: ", + "range": { + "start": 186482, + "end": 186531 + }, + "inputs": [] + }, + { + "id": "output_types", + "kind": "query_leaf", + "dsl_type": "EcxFuncSigs", + "label": "output_types: EcxFuncSigs", + "range": { + "start": 186536, + "end": 186581 + }, + "inputs": [] + }, + { + "id": "kw_return", + "kind": "query_leaf", + "dsl_type": "EcxBody", + "label": "kw_return: EcxBody", + "range": { + "start": 186586, + "end": 186624 + }, + "inputs": [] + }, + { + "id": "ty", + "kind": "query_leaf", + "dsl_type": "EcxOptionType", + "label": "ty: EcxOptionType", + "range": { + "start": 186629, + "end": 186666 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxCall", + "label": "_t2: EcxCall", + "range": { + "start": 186671, + "end": 186708 + }, + "inputs": [ + "ty", + "args" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t1: EcxPureOp", + "range": { + "start": 186713, + "end": 186746 + }, + "inputs": [ + "_t2" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxFunc", + "label": "_t3: EcxFunc", + "range": { + "start": 186751, + "end": 186812 + }, + "inputs": [ + "input_types", + "output_types", + "body" + ] + } + ], + "edges": [ + { + "from": "_t2", + "to": "ty", + "kind": "operand", + "index": 0 + }, + { + "from": "_t2", + "to": "args", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t3", + "to": "input_types", + "kind": "operand", + "index": 0 + }, + { + "from": "_t3", + "to": "output_types", + "kind": "operand", + "index": 1 + }, + { + "from": "_t3", + "to": "body", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "args", + "body", + "input_types", + "name", + "num", + "output_types", + "kw_return", + "ty", + "_t1", + "_t2", + "_t3" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "name.handle().eq(&_t2.handle_a1())", + "semantic_text": "name == _t2.a1", + "referenced_vars": [ + "_t2", + "name" + ], + "range": { + "start": 187214, + "end": 187216 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "num.handle().eq(&_t2.handle_a3())", + "semantic_text": "num == _t2.a3", + "referenced_vars": [ + "_t2", + "num" + ], + "range": { + "start": 187230, + "end": 187232 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "kw_return.handle().eq(&_t1.handle())", + "semantic_text": "kw_return == _t1", + "referenced_vars": [ + "_t1", + "kw_return" + ], + "range": { + "start": 187246, + "end": 187248 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "name.handle().eq(&_t3.handle_a0())", + "semantic_text": "name == _t3.a0", + "referenced_vars": [ + "_t3", + "name" + ], + "range": { + "start": 187262, + "end": 187264 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@252414:252470", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_subst_vec_operand_all(pat.body, pat.args)", + "semantic_text": null, + "referenced_pat_vars": [ + "args", + "body" + ], + "referenced_action_vars": [], + "range": { + "start": 252414, + "end": 252470 + } + }, + { + "id": "effect_1", + "effect_id": "effect@252489:252521", + "bound_var": "t1", + "source_text": "ctx.insert_ecx_operand_group(t2)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 252489, + "end": 252521 + } + }, + { + "id": "effect_2", + "effect_id": "effect@252531:252559", + "bound_var": null, + "source_text": "ctx.union(pat.kw_return, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "kw_return" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 252531, + "end": 252559 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0196", + "premises": [ + { + "target_id": "name", + "label": "name: ", + "plain_source": "upright(\"name\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"name\") $]" + }, + { + "target_id": "num", + "label": "num: ", + "plain_source": "upright(\"num\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"num\") $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxPureOp", + "plain_source": "upright(\"PureOp\")(upright(\"_t2\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxCall", + "plain_source": "upright(\"_t2\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxFunc", + "plain_source": "upright(\"_t3\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $]" + } + ], + "side_conditions": [ + "upright(\"name\") == upright(\"_t2.a1\")", + "upright(\"num\") == upright(\"_t2.a3\")", + "upright(\"kw_return\") == upright(\"_t1\")", + "upright(\"name\") == upright(\"_t3.a0\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"SubstVecOperandAll\")(upright(\"body\"), upright(\"args\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"args\") $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"OperandGroup\")((upright(\"SubstVecOperandAll\")(upright(\"body\"), upright(\"args\"))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"args\") $]) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "kw_return", + "label": "kw_return: EcxBody", + "plain_source": "upright(\"kw_return\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_return\") $]" + }, + "to": { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"OperandGroup\")((upright(\"SubstVecOperandAll\")(upright(\"body\"), upright(\"args\"))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"args\") $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"name\") \\ upright(\"num\") \\ upright(\"PureOp\")(upright(\"_t2\")) \\ upright(\"_t2\") \\ upright(\"_t3\"), upright(\"kw_return\") arrow.r.double upright(\"OperandGroup\")((upright(\"SubstVecOperandAll\")(upright(\"body\"), upright(\"args\"))))) quad upright(\"if\") quad upright(\"name\") == upright(\"_t2.a1\") \\ upright(\"num\") == upright(\"_t2.a3\") \\ upright(\"kw_return\") == upright(\"_t1\") \\ upright(\"name\") == upright(\"_t3.a0\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"name\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"num\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t2\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t3\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_return\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"OperandGroup\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"SubstVecOperandAll\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"body\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"args\") $]) $])) $]) quad upright(\"if\") quad upright(\"name\") == upright(\"_t2.a1\") \\ upright(\"num\") == upright(\"_t2.a3\") \\ upright(\"kw_return\") == upright(\"_t1\") \\ upright(\"name\") == upright(\"_t3.a0\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7859_5_MyTxEggccExtraction_add_rule__r0197__a2387e5cd4d29eb3", + "display_name": "r0197", + "rule_name": "r0197", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 252573, + "line": 7859, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 252573, + "end": 252790 + }, + "pattern_range": { + "start": 252624, + "end": 252635 + }, + "action_range": { + "start": 252637, + "end": 252789 + } + }, + "nodes": [ + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "lhs: EcxExpr", + "range": { + "start": 187604, + "end": 187636 + }, + "inputs": [] + }, + { + "id": "n1", + "kind": "query", + "dsl_type": "", + "label": "n1: ", + "range": { + "start": 187641, + "end": 187688 + }, + "inputs": [] + }, + { + "id": "num", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "num: EcxOperand", + "range": { + "start": 187693, + "end": 187728 + }, + "inputs": [] + }, + { + "id": "other", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "other: EcxOperand", + "range": { + "start": 187733, + "end": 187770 + }, + "inputs": [] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxIntT", + "label": "_t4: EcxIntT", + "range": { + "start": 187775, + "end": 187802 + }, + "inputs": [] + }, + { + "id": "_t5", + "kind": "query", + "dsl_type": "Ecxkw_const", + "label": "_t5: Ecxkw_const", + "range": { + "start": 187807, + "end": 187838 + }, + "inputs": [] + }, + { + "id": "_t6", + "kind": "query", + "dsl_type": "EcxNum", + "label": "_t6: EcxNum", + "range": { + "start": 187843, + "end": 187869 + }, + "inputs": [] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxConst", + "label": "_t3: EcxConst", + "range": { + "start": 187874, + "end": 187918 + }, + "inputs": [ + "_t4", + "_t5", + "_t6" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t2: EcxPureOp", + "range": { + "start": 187923, + "end": 187956 + }, + "inputs": [ + "_t3" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t1: EcxNode", + "range": { + "start": 187961, + "end": 187992 + }, + "inputs": [ + "_t2" + ] + }, + { + "id": "_t8", + "kind": "query", + "dsl_type": "EcxIntT", + "label": "_t8: EcxIntT", + "range": { + "start": 187997, + "end": 188024 + }, + "inputs": [] + }, + { + "id": "_t7", + "kind": "query", + "dsl_type": "Ecxbadd", + "label": "_t7: Ecxbadd", + "range": { + "start": 188029, + "end": 188074 + }, + "inputs": [ + "_t8", + "other", + "num" + ] + } + ], + "edges": [ + { + "from": "_t3", + "to": "_t4", + "kind": "operand", + "index": 0 + }, + { + "from": "_t3", + "to": "_t5", + "kind": "operand", + "index": 1 + }, + { + "from": "_t3", + "to": "_t6", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "_t3", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t7", + "to": "_t8", + "kind": "operand", + "index": 0 + }, + { + "from": "_t7", + "to": "other", + "kind": "operand", + "index": 1 + }, + { + "from": "_t7", + "to": "num", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "lhs", + "n1", + "num", + "other", + "_t1", + "_t2", + "_t3", + "_t4", + "_t5", + "_t6", + "_t7", + "_t8" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "n1.handle().eq(&_t6.handle_a0())", + "semantic_text": "n1 == _t6.a0", + "referenced_vars": [ + "_t6", + "n1" + ], + "range": { + "start": 188306, + "end": 188308 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "num.handle().eq(&_t1.handle())", + "semantic_text": "num == _t1", + "referenced_vars": [ + "_t1", + "num" + ], + "range": { + "start": 188326, + "end": 188328 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "lhs.handle().eq(&_t7.handle())", + "semantic_text": "lhs == _t7", + "referenced_vars": [ + "_t7", + "lhs" + ], + "range": { + "start": 188346, + "end": 188348 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@252667:252689", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_int_t()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 252667, + "end": 252689 + } + }, + { + "id": "effect_1", + "effect_id": "effect@252708:252750", + "bound_var": "t1", + "source_text": "ctx.insert_ecxbadd(t2, pat.num, pat.other)", + "semantic_text": null, + "referenced_pat_vars": [ + "num", + "other" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 252708, + "end": 252750 + } + }, + { + "id": "effect_2", + "effect_id": "effect@252760:252782", + "bound_var": null, + "source_text": "ctx.union(pat.lhs, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 252760, + "end": 252782 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0197", + "premises": [ + { + "target_id": "n1", + "label": "n1: ", + "plain_source": "n_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ n_1 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxNode", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"_t4\"), upright(\"_t5\"), upright(\"_t6\"))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxPureOp", + "plain_source": "upright(\"PureOp\")((upright(\"Const\")(upright(\"_t4\"), upright(\"_t5\"), upright(\"_t6\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxConst", + "plain_source": "upright(\"Const\")(upright(\"_t4\"), upright(\"_t5\"), upright(\"_t6\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $]" + }, + { + "target_id": "_t4", + "label": "_t4: EcxIntT", + "plain_source": "upright(\"IntT\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $]" + }, + { + "target_id": "_t5", + "label": "_t5: Ecxkw_const", + "plain_source": "upright(\"kw_const\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $]" + }, + { + "target_id": "_t6", + "label": "_t6: EcxNum", + "plain_source": "upright(\"_t6\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]" + }, + { + "target_id": "_t7", + "label": "_t7: Ecxbadd", + "plain_source": "upright(\"badd\")(upright(\"IntT\"), upright(\"other\"), upright(\"num\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"other\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"num\") $]) $]" + }, + { + "target_id": "_t8", + "label": "_t8: EcxIntT", + "plain_source": "upright(\"IntT\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $]" + } + ], + "side_conditions": [ + "n_1 == upright(\"_t6.a0\")", + "upright(\"num\") == upright(\"_t1\")", + "upright(\"lhs\") == upright(\"_t7\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"IntT\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $]" + }, + { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"badd\")(upright(\"IntT\"), upright(\"num\"), upright(\"other\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"num\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"other\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "lhs", + "label": "lhs: EcxExpr", + "plain_source": "upright(\"lhs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]" + }, + "to": { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"badd\")(upright(\"IntT\"), upright(\"num\"), upright(\"other\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"num\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"other\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(n_1 \\ upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"_t4\"), upright(\"_t5\"), upright(\"_t6\")))))) \\ upright(\"PureOp\")((upright(\"Const\")(upright(\"_t4\"), upright(\"_t5\"), upright(\"_t6\")))) \\ upright(\"Const\")(upright(\"_t4\"), upright(\"_t5\"), upright(\"_t6\")) \\ upright(\"IntT\") \\ upright(\"kw_const\") \\ upright(\"_t6\") \\ upright(\"badd\")(upright(\"IntT\"), upright(\"other\"), upright(\"num\")) \\ upright(\"IntT\"), upright(\"lhs\") arrow.r.double upright(\"badd\")(upright(\"IntT\"), upright(\"num\"), upright(\"other\"))) quad upright(\"if\") quad n_1 == upright(\"_t6.a0\") \\ upright(\"num\") == upright(\"_t1\") \\ upright(\"lhs\") == upright(\"_t7\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ n_1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"other\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"num\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"num\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"other\") $]) $]) quad upright(\"if\") quad n_1 == upright(\"_t6.a0\") \\ upright(\"num\") == upright(\"_t1\") \\ upright(\"lhs\") == upright(\"_t7\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7864_5_MyTxEggccExtraction_add_rule__r0198__e5ad0cfc8fef5a66", + "display_name": "r0198", + "rule_name": "r0198", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 252796, + "line": 7864, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 252796, + "end": 253013 + }, + "pattern_range": { + "start": 252847, + "end": 252858 + }, + "action_range": { + "start": 252860, + "end": 253012 + } + }, + "nodes": [ + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "lhs: EcxExpr", + "range": { + "start": 188688, + "end": 188720 + }, + "inputs": [] + }, + { + "id": "n1", + "kind": "query", + "dsl_type": "", + "label": "n1: ", + "range": { + "start": 188725, + "end": 188772 + }, + "inputs": [] + }, + { + "id": "num", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "num: EcxOperand", + "range": { + "start": 188777, + "end": 188812 + }, + "inputs": [] + }, + { + "id": "other", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "other: EcxOperand", + "range": { + "start": 188817, + "end": 188854 + }, + "inputs": [] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxIntT", + "label": "_t4: EcxIntT", + "range": { + "start": 188859, + "end": 188886 + }, + "inputs": [] + }, + { + "id": "_t5", + "kind": "query", + "dsl_type": "Ecxkw_const", + "label": "_t5: Ecxkw_const", + "range": { + "start": 188891, + "end": 188922 + }, + "inputs": [] + }, + { + "id": "_t6", + "kind": "query", + "dsl_type": "EcxNum", + "label": "_t6: EcxNum", + "range": { + "start": 188927, + "end": 188953 + }, + "inputs": [] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxConst", + "label": "_t3: EcxConst", + "range": { + "start": 188958, + "end": 189002 + }, + "inputs": [ + "_t4", + "_t5", + "_t6" + ] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t2: EcxPureOp", + "range": { + "start": 189007, + "end": 189040 + }, + "inputs": [ + "_t3" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t1: EcxNode", + "range": { + "start": 189045, + "end": 189076 + }, + "inputs": [ + "_t2" + ] + }, + { + "id": "_t8", + "kind": "query", + "dsl_type": "EcxIntT", + "label": "_t8: EcxIntT", + "range": { + "start": 189081, + "end": 189108 + }, + "inputs": [] + }, + { + "id": "_t7", + "kind": "query", + "dsl_type": "Ecxbmul", + "label": "_t7: Ecxbmul", + "range": { + "start": 189113, + "end": 189158 + }, + "inputs": [ + "_t8", + "other", + "num" + ] + } + ], + "edges": [ + { + "from": "_t3", + "to": "_t4", + "kind": "operand", + "index": 0 + }, + { + "from": "_t3", + "to": "_t5", + "kind": "operand", + "index": 1 + }, + { + "from": "_t3", + "to": "_t6", + "kind": "operand", + "index": 2 + }, + { + "from": "_t2", + "to": "_t3", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t7", + "to": "_t8", + "kind": "operand", + "index": 0 + }, + { + "from": "_t7", + "to": "other", + "kind": "operand", + "index": 1 + }, + { + "from": "_t7", + "to": "num", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "lhs", + "n1", + "num", + "other", + "_t1", + "_t2", + "_t3", + "_t4", + "_t5", + "_t6", + "_t7", + "_t8" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "n1.handle().eq(&_t6.handle_a0())", + "semantic_text": "n1 == _t6.a0", + "referenced_vars": [ + "_t6", + "n1" + ], + "range": { + "start": 189390, + "end": 189392 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "num.handle().eq(&_t1.handle())", + "semantic_text": "num == _t1", + "referenced_vars": [ + "_t1", + "num" + ], + "range": { + "start": 189410, + "end": 189412 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "lhs.handle().eq(&_t7.handle())", + "semantic_text": "lhs == _t7", + "referenced_vars": [ + "_t7", + "lhs" + ], + "range": { + "start": 189430, + "end": 189432 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@252890:252912", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_int_t()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 252890, + "end": 252912 + } + }, + { + "id": "effect_1", + "effect_id": "effect@252931:252973", + "bound_var": "t1", + "source_text": "ctx.insert_ecxbmul(t2, pat.num, pat.other)", + "semantic_text": null, + "referenced_pat_vars": [ + "num", + "other" + ], + "referenced_action_vars": [ + "t2" + ], + "range": { + "start": 252931, + "end": 252973 + } + }, + { + "id": "effect_2", + "effect_id": "effect@252983:253005", + "bound_var": null, + "source_text": "ctx.union(pat.lhs, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 252983, + "end": 253005 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0198", + "premises": [ + { + "target_id": "n1", + "label": "n1: ", + "plain_source": "n_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ n_1 $]" + }, + { + "target_id": "_t1", + "label": "_t1: EcxNode", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"_t4\"), upright(\"_t5\"), upright(\"_t6\"))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxPureOp", + "plain_source": "upright(\"PureOp\")((upright(\"Const\")(upright(\"_t4\"), upright(\"_t5\"), upright(\"_t6\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxConst", + "plain_source": "upright(\"Const\")(upright(\"_t4\"), upright(\"_t5\"), upright(\"_t6\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $]" + }, + { + "target_id": "_t4", + "label": "_t4: EcxIntT", + "plain_source": "upright(\"IntT\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $]" + }, + { + "target_id": "_t5", + "label": "_t5: Ecxkw_const", + "plain_source": "upright(\"kw_const\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $]" + }, + { + "target_id": "_t6", + "label": "_t6: EcxNum", + "plain_source": "upright(\"_t6\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]" + }, + { + "target_id": "_t7", + "label": "_t7: Ecxbmul", + "plain_source": "upright(\"bmul\")(upright(\"IntT\"), upright(\"other\"), upright(\"num\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"other\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"num\") $]) $]" + }, + { + "target_id": "_t8", + "label": "_t8: EcxIntT", + "plain_source": "upright(\"IntT\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $]" + } + ], + "side_conditions": [ + "n_1 == upright(\"_t6.a0\")", + "upright(\"num\") == upright(\"_t1\")", + "upright(\"lhs\") == upright(\"_t7\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"IntT\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $]" + }, + { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"bmul\")(upright(\"IntT\"), upright(\"num\"), upright(\"other\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"num\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"other\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "lhs", + "label": "lhs: EcxExpr", + "plain_source": "upright(\"lhs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]" + }, + "to": { + "target_id": "effect:effect_1", + "label": "t1", + "plain_source": "upright(\"bmul\")(upright(\"IntT\"), upright(\"num\"), upright(\"other\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"num\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"other\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(n_1 \\ upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"_t4\"), upright(\"_t5\"), upright(\"_t6\")))))) \\ upright(\"PureOp\")((upright(\"Const\")(upright(\"_t4\"), upright(\"_t5\"), upright(\"_t6\")))) \\ upright(\"Const\")(upright(\"_t4\"), upright(\"_t5\"), upright(\"_t6\")) \\ upright(\"IntT\") \\ upright(\"kw_const\") \\ upright(\"_t6\") \\ upright(\"bmul\")(upright(\"IntT\"), upright(\"other\"), upright(\"num\")) \\ upright(\"IntT\"), upright(\"lhs\") arrow.r.double upright(\"bmul\")(upright(\"IntT\"), upright(\"num\"), upright(\"other\"))) quad upright(\"if\") quad n_1 == upright(\"_t6.a0\") \\ upright(\"num\") == upright(\"_t1\") \\ upright(\"lhs\") == upright(\"_t7\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ n_1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t4\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t5\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t6\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"other\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"num\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"bmul\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"num\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"other\") $]) $]) quad upright(\"if\") quad n_1 == upright(\"_t6.a0\") \\ upright(\"num\") == upright(\"_t1\") \\ upright(\"lhs\") == upright(\"_t7\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7869_5_MyTxEggccExtraction_add_rule__r0199__ad78226f47682f1e", + "display_name": "r0199", + "rule_name": "r0199", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 253019, + "line": 7869, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 253019, + "end": 253410 + }, + "pattern_range": { + "start": 253070, + "end": 253081 + }, + "action_range": { + "start": 253083, + "end": 253409 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 189732, + "end": 189765 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 189770, + "end": 189803 + }, + "inputs": [] + }, + { + "id": "c", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "c: EcxOperand", + "range": { + "start": 189808, + "end": 189841 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "lhs: EcxExpr", + "range": { + "start": 189846, + "end": 189878 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxIntT", + "label": "_t2: EcxIntT", + "range": { + "start": 189883, + "end": 189910 + }, + "inputs": [] + }, + { + "id": "_t6", + "kind": "query", + "dsl_type": "EcxIntT", + "label": "_t6: EcxIntT", + "range": { + "start": 189915, + "end": 189942 + }, + "inputs": [] + }, + { + "id": "_t5", + "kind": "query", + "dsl_type": "Ecxbadd", + "label": "_t5: Ecxbadd", + "range": { + "start": 189947, + "end": 189986 + }, + "inputs": [ + "_t6", + "a", + "b" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t4: EcxPureOp", + "range": { + "start": 189991, + "end": 190024 + }, + "inputs": [ + "_t5" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t3: EcxNode", + "range": { + "start": 190029, + "end": 190060 + }, + "inputs": [ + "_t4" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "Ecxbadd", + "label": "_t1: Ecxbadd", + "range": { + "start": 190065, + "end": 190106 + }, + "inputs": [ + "_t2", + "_t3", + "c" + ] + } + ], + "edges": [ + { + "from": "_t5", + "to": "_t6", + "kind": "operand", + "index": 0 + }, + { + "from": "_t5", + "to": "a", + "kind": "operand", + "index": 1 + }, + { + "from": "_t5", + "to": "b", + "kind": "operand", + "index": 2 + }, + { + "from": "_t4", + "to": "_t5", + "kind": "operand", + "index": 0 + }, + { + "from": "_t3", + "to": "_t4", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t3", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "c", + "kind": "operand", + "index": 2 + } + ], + "roots": [ + "a", + "b", + "c", + "lhs", + "_t1", + "_t2", + "_t3", + "_t4", + "_t5", + "_t6" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 190220, + "end": 190222 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@253113:253135", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_int_t()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 253113, + "end": 253135 + } + }, + { + "id": "effect_1", + "effect_id": "effect@253154:253176", + "bound_var": "t6", + "source_text": "ctx.insert_ecx_int_t()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 253154, + "end": 253176 + } + }, + { + "id": "effect_2", + "effect_id": "effect@253195:253231", + "bound_var": "t5", + "source_text": "ctx.insert_ecxbadd(t6, pat.b, pat.c)", + "semantic_text": null, + "referenced_pat_vars": [ + "b", + "c" + ], + "referenced_action_vars": [ + "t6" + ], + "range": { + "start": 253195, + "end": 253231 + } + }, + { + "id": "effect_3", + "effect_id": "effect@253250:253276", + "bound_var": "t4", + "source_text": "ctx.insert_ecx_pure_op(t5)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t5" + ], + "range": { + "start": 253250, + "end": 253276 + } + }, + { + "id": "effect_4", + "effect_id": "effect@253295:253318", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_node(t4)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t4" + ], + "range": { + "start": 253295, + "end": 253318 + } + }, + { + "id": "effect_5", + "effect_id": "effect@253337:253370", + "bound_var": "t1", + "source_text": "ctx.insert_ecxbadd(t2, pat.a, t3)", + "semantic_text": null, + "referenced_pat_vars": [ + "a" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 253337, + "end": 253370 + } + }, + { + "id": "effect_6", + "effect_id": "effect@253380:253402", + "bound_var": null, + "source_text": "ctx.union(pat.lhs, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 253380, + "end": 253402 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0199", + "premises": [ + { + "target_id": "_t1", + "label": "_t1: Ecxbadd", + "plain_source": "upright(\"badd\")(upright(\"IntT\"), (upright(\"Node\")((upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), a, b)))))), c)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $])) $])) $]), #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxIntT", + "plain_source": "upright(\"IntT\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxNode", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), a, b)))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $])) $])) $]" + }, + { + "target_id": "_t4", + "label": "_t4: EcxPureOp", + "plain_source": "upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), a, b)))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $])) $]" + }, + { + "target_id": "_t5", + "label": "_t5: Ecxbadd", + "plain_source": "upright(\"badd\")(upright(\"IntT\"), a, b)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $]" + }, + { + "target_id": "_t6", + "label": "_t6: EcxIntT", + "plain_source": "upright(\"IntT\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $]" + } + ], + "side_conditions": [ + "upright(\"lhs\") == upright(\"_t1\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"IntT\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $]" + }, + { + "target_id": "effect:effect_1", + "label": "t6", + "plain_source": "upright(\"IntT\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $]" + }, + { + "target_id": "effect:effect_2", + "label": "t5", + "plain_source": "upright(\"badd\")(upright(\"IntT\"), b, c)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $]" + }, + { + "target_id": "effect:effect_3", + "label": "t4", + "plain_source": "upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), b, c)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $])) $]" + }, + { + "target_id": "effect:effect_4", + "label": "t3", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), b, c)))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Node\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $])) $])) $]" + }, + { + "target_id": "effect:effect_5", + "label": "t1", + "plain_source": "upright(\"badd\")(upright(\"IntT\"), a, (upright(\"Node\")((upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), b, c)))))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Node\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $])) $])) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_6", + "from": { + "target_id": "lhs", + "label": "lhs: EcxExpr", + "plain_source": "upright(\"lhs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]" + }, + "to": { + "target_id": "effect:effect_5", + "label": "t1", + "plain_source": "upright(\"badd\")(upright(\"IntT\"), a, (upright(\"Node\")((upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), b, c)))))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Node\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $])) $])) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"badd\")(upright(\"IntT\"), (upright(\"Node\")((upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), a, b)))))), c) \\ upright(\"IntT\") \\ upright(\"Node\")((upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), a, b))))) \\ upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), a, b))) \\ upright(\"badd\")(upright(\"IntT\"), a, b) \\ upright(\"IntT\"), upright(\"lhs\") arrow.r.double upright(\"badd\")(upright(\"IntT\"), a, (upright(\"Node\")((upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), b, c)))))))) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $])) $])) $]), #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ b $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Node\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $])) $])) $])) $]) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7878_5_MyTxEggccExtraction_add_rule__r0200__09183c612ebcf3d3", + "display_name": "r0200", + "rule_name": "r0200", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 253416, + "line": 7878, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 253416, + "end": 253807 + }, + "pattern_range": { + "start": 253467, + "end": 253478 + }, + "action_range": { + "start": 253480, + "end": 253806 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 190652, + "end": 190685 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 190690, + "end": 190723 + }, + "inputs": [] + }, + { + "id": "c", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "c: EcxOperand", + "range": { + "start": 190728, + "end": 190761 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "lhs: EcxExpr", + "range": { + "start": 190766, + "end": 190798 + }, + "inputs": [] + }, + { + "id": "n1", + "kind": "query", + "dsl_type": "", + "label": "n1: ", + "range": { + "start": 190803, + "end": 190850 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxIntT", + "label": "_t2: EcxIntT", + "range": { + "start": 190855, + "end": 190882 + }, + "inputs": [] + }, + { + "id": "_t6", + "kind": "query", + "dsl_type": "EcxIntT", + "label": "_t6: EcxIntT", + "range": { + "start": 190887, + "end": 190914 + }, + "inputs": [] + }, + { + "id": "_t5", + "kind": "query", + "dsl_type": "Ecxbadd", + "label": "_t5: Ecxbadd", + "range": { + "start": 190919, + "end": 190958 + }, + "inputs": [ + "_t6", + "b", + "c" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t4: EcxPureOp", + "range": { + "start": 190963, + "end": 190996 + }, + "inputs": [ + "_t5" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t3: EcxNode", + "range": { + "start": 191001, + "end": 191032 + }, + "inputs": [ + "_t4" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "Ecxbadd", + "label": "_t1: Ecxbadd", + "range": { + "start": 191037, + "end": 191078 + }, + "inputs": [ + "_t2", + "a", + "_t3" + ] + }, + { + "id": "_t10", + "kind": "query", + "dsl_type": "EcxIntT", + "label": "_t10: EcxIntT", + "range": { + "start": 191083, + "end": 191111 + }, + "inputs": [] + }, + { + "id": "_t11", + "kind": "query", + "dsl_type": "Ecxkw_const", + "label": "_t11: Ecxkw_const", + "range": { + "start": 191116, + "end": 191148 + }, + "inputs": [] + }, + { + "id": "_t12", + "kind": "query", + "dsl_type": "EcxNum", + "label": "_t12: EcxNum", + "range": { + "start": 191153, + "end": 191180 + }, + "inputs": [] + }, + { + "id": "_t9", + "kind": "query", + "dsl_type": "EcxConst", + "label": "_t9: EcxConst", + "range": { + "start": 191185, + "end": 191232 + }, + "inputs": [ + "_t10", + "_t11", + "_t12" + ] + }, + { + "id": "_t8", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t8: EcxPureOp", + "range": { + "start": 191237, + "end": 191270 + }, + "inputs": [ + "_t9" + ] + }, + { + "id": "_t7", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t7: EcxNode", + "range": { + "start": 191275, + "end": 191306 + }, + "inputs": [ + "_t8" + ] + } + ], + "edges": [ + { + "from": "_t5", + "to": "_t6", + "kind": "operand", + "index": 0 + }, + { + "from": "_t5", + "to": "b", + "kind": "operand", + "index": 1 + }, + { + "from": "_t5", + "to": "c", + "kind": "operand", + "index": 2 + }, + { + "from": "_t4", + "to": "_t5", + "kind": "operand", + "index": 0 + }, + { + "from": "_t3", + "to": "_t4", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "a", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "_t3", + "kind": "operand", + "index": 2 + }, + { + "from": "_t9", + "to": "_t10", + "kind": "operand", + "index": 0 + }, + { + "from": "_t9", + "to": "_t11", + "kind": "operand", + "index": 1 + }, + { + "from": "_t9", + "to": "_t12", + "kind": "operand", + "index": 2 + }, + { + "from": "_t8", + "to": "_t9", + "kind": "operand", + "index": 0 + }, + { + "from": "_t7", + "to": "_t8", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "a", + "b", + "c", + "lhs", + "n1", + "_t1", + "_t2", + "_t3", + "_t4", + "_t5", + "_t6", + "_t7", + "_t8", + "_t9", + "_t10", + "_t11", + "_t12" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 191568, + "end": 191570 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "n1.handle().eq(&_t12.handle_a0())", + "semantic_text": "n1 == _t12.a0", + "referenced_vars": [ + "_t12", + "n1" + ], + "range": { + "start": 191584, + "end": 191586 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "b.handle().eq(&_t7.handle())", + "semantic_text": "b == _t7", + "referenced_vars": [ + "_t7", + "b" + ], + "range": { + "start": 191600, + "end": 191602 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@253510:253532", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_int_t()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 253510, + "end": 253532 + } + }, + { + "id": "effect_1", + "effect_id": "effect@253551:253573", + "bound_var": "t6", + "source_text": "ctx.insert_ecx_int_t()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 253551, + "end": 253573 + } + }, + { + "id": "effect_2", + "effect_id": "effect@253592:253628", + "bound_var": "t5", + "source_text": "ctx.insert_ecxbadd(t6, pat.a, pat.c)", + "semantic_text": null, + "referenced_pat_vars": [ + "a", + "c" + ], + "referenced_action_vars": [ + "t6" + ], + "range": { + "start": 253592, + "end": 253628 + } + }, + { + "id": "effect_3", + "effect_id": "effect@253647:253673", + "bound_var": "t4", + "source_text": "ctx.insert_ecx_pure_op(t5)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t5" + ], + "range": { + "start": 253647, + "end": 253673 + } + }, + { + "id": "effect_4", + "effect_id": "effect@253692:253715", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_node(t4)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t4" + ], + "range": { + "start": 253692, + "end": 253715 + } + }, + { + "id": "effect_5", + "effect_id": "effect@253734:253767", + "bound_var": "t1", + "source_text": "ctx.insert_ecxbadd(t2, pat.b, t3)", + "semantic_text": null, + "referenced_pat_vars": [ + "b" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 253734, + "end": 253767 + } + }, + { + "id": "effect_6", + "effect_id": "effect@253777:253799", + "bound_var": null, + "source_text": "ctx.union(pat.lhs, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 253777, + "end": 253799 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0200", + "premises": [ + { + "target_id": "n1", + "label": "n1: ", + "plain_source": "n_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ n_1 $]" + }, + { + "target_id": "_t1", + "label": "_t1: Ecxbadd", + "plain_source": "upright(\"badd\")(upright(\"IntT\"), a, (upright(\"Node\")((upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), b, c)))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $])) $])) $])) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxIntT", + "plain_source": "upright(\"IntT\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxNode", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), b, c)))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $])) $])) $]" + }, + { + "target_id": "_t4", + "label": "_t4: EcxPureOp", + "plain_source": "upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), b, c)))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $])) $]" + }, + { + "target_id": "_t5", + "label": "_t5: Ecxbadd", + "plain_source": "upright(\"badd\")(upright(\"IntT\"), b, c)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $]" + }, + { + "target_id": "_t6", + "label": "_t6: EcxIntT", + "plain_source": "upright(\"IntT\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $]" + }, + { + "target_id": "_t7", + "label": "_t7: EcxNode", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"_t10\"), upright(\"_t11\"), upright(\"_t12\"))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t12\") $]) $])) $])) $]" + }, + { + "target_id": "_t8", + "label": "_t8: EcxPureOp", + "plain_source": "upright(\"PureOp\")((upright(\"Const\")(upright(\"_t10\"), upright(\"_t11\"), upright(\"_t12\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t12\") $]) $])) $]" + }, + { + "target_id": "_t9", + "label": "_t9: EcxConst", + "plain_source": "upright(\"Const\")(upright(\"_t10\"), upright(\"_t11\"), upright(\"_t12\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t12\") $]) $]" + }, + { + "target_id": "_t10", + "label": "_t10: EcxIntT", + "plain_source": "upright(\"IntT\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $]" + }, + { + "target_id": "_t11", + "label": "_t11: Ecxkw_const", + "plain_source": "upright(\"kw_const\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $]" + }, + { + "target_id": "_t12", + "label": "_t12: EcxNum", + "plain_source": "upright(\"_t12\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t12\") $]" + } + ], + "side_conditions": [ + "upright(\"lhs\") == upright(\"_t1\")", + "n_1 == upright(\"_t12.a0\")", + "b == upright(\"_t7\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"IntT\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $]" + }, + { + "target_id": "effect:effect_1", + "label": "t6", + "plain_source": "upright(\"IntT\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $]" + }, + { + "target_id": "effect:effect_2", + "label": "t5", + "plain_source": "upright(\"badd\")(upright(\"IntT\"), a, c)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $]" + }, + { + "target_id": "effect:effect_3", + "label": "t4", + "plain_source": "upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), a, c)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $])) $]" + }, + { + "target_id": "effect:effect_4", + "label": "t3", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), a, c)))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Node\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $])) $])) $]" + }, + { + "target_id": "effect:effect_5", + "label": "t1", + "plain_source": "upright(\"badd\")(upright(\"IntT\"), b, (upright(\"Node\")((upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), a, c)))))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ b $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Node\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $])) $])) $])) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_6", + "from": { + "target_id": "lhs", + "label": "lhs: EcxExpr", + "plain_source": "upright(\"lhs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]" + }, + "to": { + "target_id": "effect:effect_5", + "label": "t1", + "plain_source": "upright(\"badd\")(upright(\"IntT\"), b, (upright(\"Node\")((upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), a, c)))))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ b $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Node\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $])) $])) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(n_1 \\ upright(\"badd\")(upright(\"IntT\"), a, (upright(\"Node\")((upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), b, c))))))) \\ upright(\"IntT\") \\ upright(\"Node\")((upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), b, c))))) \\ upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), b, c))) \\ upright(\"badd\")(upright(\"IntT\"), b, c) \\ upright(\"IntT\") \\ upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"_t10\"), upright(\"_t11\"), upright(\"_t12\")))))) \\ upright(\"PureOp\")((upright(\"Const\")(upright(\"_t10\"), upright(\"_t11\"), upright(\"_t12\")))) \\ upright(\"Const\")(upright(\"_t10\"), upright(\"_t11\"), upright(\"_t12\")) \\ upright(\"IntT\") \\ upright(\"kw_const\") \\ upright(\"_t12\"), upright(\"lhs\") arrow.r.double upright(\"badd\")(upright(\"IntT\"), b, (upright(\"Node\")((upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), a, c)))))))) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\") \\ n_1 == upright(\"_t12.a0\") \\ b == upright(\"_t7\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ n_1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $])) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t12\") $]) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t12\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t12\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t12\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ b $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Node\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $])) $])) $])) $]) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\") \\ n_1 == upright(\"_t12.a0\") \\ b == upright(\"_t7\")" + } + } + } + }, + { + "id": "benches_runners_generated_eggcc_extraction_rs__7887_5_MyTxEggccExtraction_add_rule__r0201__d5bc3a972d0ca566", + "display_name": "r0201", + "rule_name": "r0201", + "callee": "MyTxEggccExtraction::add_rule", + "file": "benches/runners/generated/eggcc_extraction.rs", + "offset": 253813, + "line": 7887, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 253813, + "end": 254325 + }, + "pattern_range": { + "start": 253864, + "end": 253875 + }, + "action_range": { + "start": 253877, + "end": 254324 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "a: EcxOperand", + "range": { + "start": 192165, + "end": 192198 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "b: EcxOperand", + "range": { + "start": 192203, + "end": 192236 + }, + "inputs": [] + }, + { + "id": "c", + "kind": "query_leaf", + "dsl_type": "EcxOperand", + "label": "c: EcxOperand", + "range": { + "start": 192241, + "end": 192274 + }, + "inputs": [] + }, + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "EcxExpr", + "label": "lhs: EcxExpr", + "range": { + "start": 192279, + "end": 192311 + }, + "inputs": [] + }, + { + "id": "n1", + "kind": "query", + "dsl_type": "", + "label": "n1: ", + "range": { + "start": 192316, + "end": 192363 + }, + "inputs": [] + }, + { + "id": "n2", + "kind": "query", + "dsl_type": "", + "label": "n2: ", + "range": { + "start": 192368, + "end": 192415 + }, + "inputs": [] + }, + { + "id": "_t2", + "kind": "query", + "dsl_type": "EcxIntT", + "label": "_t2: EcxIntT", + "range": { + "start": 192420, + "end": 192447 + }, + "inputs": [] + }, + { + "id": "_t6", + "kind": "query", + "dsl_type": "EcxIntT", + "label": "_t6: EcxIntT", + "range": { + "start": 192452, + "end": 192479 + }, + "inputs": [] + }, + { + "id": "_t5", + "kind": "query", + "dsl_type": "Ecxbadd", + "label": "_t5: Ecxbadd", + "range": { + "start": 192484, + "end": 192523 + }, + "inputs": [ + "_t6", + "b", + "c" + ] + }, + { + "id": "_t4", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t4: EcxPureOp", + "range": { + "start": 192528, + "end": 192561 + }, + "inputs": [ + "_t5" + ] + }, + { + "id": "_t3", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t3: EcxNode", + "range": { + "start": 192566, + "end": 192597 + }, + "inputs": [ + "_t4" + ] + }, + { + "id": "_t1", + "kind": "query", + "dsl_type": "Ecxbadd", + "label": "_t1: Ecxbadd", + "range": { + "start": 192602, + "end": 192643 + }, + "inputs": [ + "_t2", + "a", + "_t3" + ] + }, + { + "id": "_t10", + "kind": "query", + "dsl_type": "EcxIntT", + "label": "_t10: EcxIntT", + "range": { + "start": 192648, + "end": 192676 + }, + "inputs": [] + }, + { + "id": "_t11", + "kind": "query", + "dsl_type": "Ecxkw_const", + "label": "_t11: Ecxkw_const", + "range": { + "start": 192681, + "end": 192713 + }, + "inputs": [] + }, + { + "id": "_t12", + "kind": "query", + "dsl_type": "EcxNum", + "label": "_t12: EcxNum", + "range": { + "start": 192718, + "end": 192745 + }, + "inputs": [] + }, + { + "id": "_t9", + "kind": "query", + "dsl_type": "EcxConst", + "label": "_t9: EcxConst", + "range": { + "start": 192750, + "end": 192797 + }, + "inputs": [ + "_t10", + "_t11", + "_t12" + ] + }, + { + "id": "_t8", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t8: EcxPureOp", + "range": { + "start": 192802, + "end": 192835 + }, + "inputs": [ + "_t9" + ] + }, + { + "id": "_t7", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t7: EcxNode", + "range": { + "start": 192840, + "end": 192871 + }, + "inputs": [ + "_t8" + ] + }, + { + "id": "_t16", + "kind": "query", + "dsl_type": "EcxIntT", + "label": "_t16: EcxIntT", + "range": { + "start": 192876, + "end": 192904 + }, + "inputs": [] + }, + { + "id": "_t17", + "kind": "query", + "dsl_type": "Ecxkw_const", + "label": "_t17: Ecxkw_const", + "range": { + "start": 192909, + "end": 192941 + }, + "inputs": [] + }, + { + "id": "_t18", + "kind": "query", + "dsl_type": "EcxNum", + "label": "_t18: EcxNum", + "range": { + "start": 192946, + "end": 192973 + }, + "inputs": [] + }, + { + "id": "_t15", + "kind": "query", + "dsl_type": "EcxConst", + "label": "_t15: EcxConst", + "range": { + "start": 192978, + "end": 193026 + }, + "inputs": [ + "_t16", + "_t17", + "_t18" + ] + }, + { + "id": "_t14", + "kind": "query", + "dsl_type": "EcxPureOp", + "label": "_t14: EcxPureOp", + "range": { + "start": 193031, + "end": 193066 + }, + "inputs": [ + "_t15" + ] + }, + { + "id": "_t13", + "kind": "query", + "dsl_type": "EcxNode", + "label": "_t13: EcxNode", + "range": { + "start": 193071, + "end": 193104 + }, + "inputs": [ + "_t14" + ] + } + ], + "edges": [ + { + "from": "_t5", + "to": "_t6", + "kind": "operand", + "index": 0 + }, + { + "from": "_t5", + "to": "b", + "kind": "operand", + "index": 1 + }, + { + "from": "_t5", + "to": "c", + "kind": "operand", + "index": 2 + }, + { + "from": "_t4", + "to": "_t5", + "kind": "operand", + "index": 0 + }, + { + "from": "_t3", + "to": "_t4", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "_t2", + "kind": "operand", + "index": 0 + }, + { + "from": "_t1", + "to": "a", + "kind": "operand", + "index": 1 + }, + { + "from": "_t1", + "to": "_t3", + "kind": "operand", + "index": 2 + }, + { + "from": "_t9", + "to": "_t10", + "kind": "operand", + "index": 0 + }, + { + "from": "_t9", + "to": "_t11", + "kind": "operand", + "index": 1 + }, + { + "from": "_t9", + "to": "_t12", + "kind": "operand", + "index": 2 + }, + { + "from": "_t8", + "to": "_t9", + "kind": "operand", + "index": 0 + }, + { + "from": "_t7", + "to": "_t8", + "kind": "operand", + "index": 0 + }, + { + "from": "_t15", + "to": "_t16", + "kind": "operand", + "index": 0 + }, + { + "from": "_t15", + "to": "_t17", + "kind": "operand", + "index": 1 + }, + { + "from": "_t15", + "to": "_t18", + "kind": "operand", + "index": 2 + }, + { + "from": "_t14", + "to": "_t15", + "kind": "operand", + "index": 0 + }, + { + "from": "_t13", + "to": "_t14", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "a", + "b", + "c", + "lhs", + "n1", + "n2", + "_t1", + "_t2", + "_t3", + "_t4", + "_t5", + "_t6", + "_t7", + "_t8", + "_t9", + "_t10", + "_t11", + "_t12", + "_t13", + "_t14", + "_t15", + "_t16", + "_t17", + "_t18" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "c0", + "resolved_text": "lhs.handle().eq(&_t1.handle())", + "semantic_text": "lhs == _t1", + "referenced_vars": [ + "_t1", + "lhs" + ], + "range": { + "start": 193506, + "end": 193508 + } + }, + { + "id": "constraint_1", + "source_text": "c1", + "resolved_text": "n1.handle().eq(&_t12.handle_a0())", + "semantic_text": "n1 == _t12.a0", + "referenced_vars": [ + "_t12", + "n1" + ], + "range": { + "start": 193522, + "end": 193524 + } + }, + { + "id": "constraint_2", + "source_text": "c2", + "resolved_text": "a.handle().eq(&_t7.handle())", + "semantic_text": "a == _t7", + "referenced_vars": [ + "_t7", + "a" + ], + "range": { + "start": 193538, + "end": 193540 + } + }, + { + "id": "constraint_3", + "source_text": "c3", + "resolved_text": "n2.handle().eq(&_t18.handle_a0())", + "semantic_text": "n2 == _t18.a0", + "referenced_vars": [ + "_t18", + "n2" + ], + "range": { + "start": 193554, + "end": 193556 + } + }, + { + "id": "constraint_4", + "source_text": "c4", + "resolved_text": "b.handle().eq(&_t13.handle())", + "semantic_text": "b == _t13", + "referenced_vars": [ + "_t13", + "b" + ], + "range": { + "start": 193570, + "end": 193572 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@253907:253929", + "bound_var": "t2", + "source_text": "ctx.insert_ecx_int_t()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 253907, + "end": 253929 + } + }, + { + "id": "effect_1", + "effect_id": "effect@253948:253970", + "bound_var": "t6", + "source_text": "ctx.insert_ecx_int_t()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 253948, + "end": 253970 + } + }, + { + "id": "effect_2", + "effect_id": "effect@253989:254013", + "bound_var": "t7", + "source_text": "ctx.insert_ecxkw_const()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 253989, + "end": 254013 + } + }, + { + "id": "effect_3", + "effect_id": "effect@254032:254095", + "bound_var": "t8", + "source_text": "ctx.insert_ecx_num((ctx.devalue(pat.n1) + ctx.devalue(pat.n2)))", + "semantic_text": null, + "referenced_pat_vars": [ + "n1", + "n2" + ], + "referenced_action_vars": [], + "range": { + "start": 254032, + "end": 254095 + } + }, + { + "id": "effect_4", + "effect_id": "effect@254114:254146", + "bound_var": "t5", + "source_text": "ctx.insert_ecx_const(t6, t7, t8)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t6", + "t7", + "t8" + ], + "range": { + "start": 254114, + "end": 254146 + } + }, + { + "id": "effect_5", + "effect_id": "effect@254165:254191", + "bound_var": "t4", + "source_text": "ctx.insert_ecx_pure_op(t5)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t5" + ], + "range": { + "start": 254165, + "end": 254191 + } + }, + { + "id": "effect_6", + "effect_id": "effect@254210:254233", + "bound_var": "t3", + "source_text": "ctx.insert_ecx_node(t4)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "t4" + ], + "range": { + "start": 254210, + "end": 254233 + } + }, + { + "id": "effect_7", + "effect_id": "effect@254252:254285", + "bound_var": "t1", + "source_text": "ctx.insert_ecxbadd(t2, t3, pat.c)", + "semantic_text": null, + "referenced_pat_vars": [ + "c" + ], + "referenced_action_vars": [ + "t2", + "t3" + ], + "range": { + "start": 254252, + "end": 254285 + } + }, + { + "id": "effect_8", + "effect_id": "effect@254295:254317", + "bound_var": null, + "source_text": "ctx.union(pat.lhs, t1)", + "semantic_text": null, + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "t1" + ], + "range": { + "start": 254295, + "end": 254317 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "EcxGamma", + "template": "Gamma({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxOperandGroup", + "template": "OperandGroup({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPureOp", + "template": "PureOp({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxShiftBody", + "template": "ShiftBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBody", + "template": "SubstBody({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstBodyAll", + "template": "SubstBodyAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxTheta", + "template": "Theta({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxkw_const", + "template": "kw_const", + "fields": [] + }, + { + "variant_name": "EcxBril", + "template": "Bril({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPrintState", + "template": "PrintState", + "fields": [] + }, + { + "variant_name": "EcxCall", + "template": "Call({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxConst", + "template": "Const({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxPRINT", + "template": "PRINT({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftExpr", + "template": "ShiftExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExpr", + "template": "SubstExpr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstExprAll", + "template": "SubstExprAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxbadd", + "template": "badd({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxband", + "template": "band({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbdiv", + "template": "bdiv({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbeq", + "template": "beq({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbfmul", + "template": "bfmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbge", + "template": "bge({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbgt", + "template": "bgt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxble", + "template": "ble({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxblt", + "template": "blt({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbmul", + "template": "bmul({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbnot", + "template": "bnot({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbor", + "template": "bor({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxbsub", + "template": "bsub({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxFunc", + "template": "Func({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxBoolI", + "template": "BoolI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxIntI", + "template": "IntI({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_intersect", + "template": "interval_intersect({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "Ecxinterval_union", + "template": "interval_union({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBool", + "template": "Bool({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxChar", + "template": "Char({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFloat", + "template": "Float({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNum", + "template": "Num({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxArg", + "template": "Arg({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxNode", + "template": "Node({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxProject", + "template": "Project({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftOperand", + "template": "ShiftOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperand", + "template": "SubstOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstOperandAll", + "template": "SubstOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperand_get", + "template": "VecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxNoneType", + "template": "NoneType", + "fields": [] + }, + { + "variant_name": "EcxSomeType", + "template": "SomeType({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyAndCost", + "template": "BodyAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxExprAndCost", + "template": "ExprAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxOperandAndCost", + "template": "OperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSmaller", + "template": "Smaller({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecOperandAndCost", + "template": "VecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "template": "VecVecOperandAndCost({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBoolT", + "template": "BoolT", + "fields": [] + }, + { + "variant_name": "EcxCharT", + "template": "CharT", + "fields": [] + }, + { + "variant_name": "EcxFloatT", + "template": "FloatT", + "fields": [] + }, + { + "variant_name": "EcxIntT", + "template": "IntT", + "fields": [] + }, + { + "variant_name": "EcxPointerT", + "template": "PointerT({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBodyToVecOperand", + "template": "BodyToVecOperand({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "template": "BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxPassThroughArguments", + "template": "PassThroughArguments({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "template": "PassThroughArgumentsHelper({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecOperand", + "template": "ShiftVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "template": "ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperand", + "template": "SubstVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "template": "SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll", + "template": "SubstVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "template": "SubstVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVO", + "template": "VO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_get", + "template": "VecVecOperand_get({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand", + "template": "ShiftVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "template": "ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand", + "template": "SubstVecVecOperand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "template": "SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})", + "fields": [ + "a0", + "a1", + "a2", + "a3" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "template": "SubstVecVecOperandAll({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "template": "SubstVecVecOperandAll_helper({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxVVO", + "template": "VVO({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxBody_contains_Body", + "template": "Body_contains_Body({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Expr", + "template": "Body_contains_Expr({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_contains_Operand", + "template": "Body_contains_Operand({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "EcxBody_is_pure", + "template": "Body_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxExpr_is_pure", + "template": "Expr_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxFunction_is_pure", + "template": "Function_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxOperand_is_pure", + "template": "Operand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecOperand_is_pure", + "template": "VecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "template": "VecVecOperand_is_pure({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "template": "can_subst_Body_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "template": "can_subst_Expr_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "template": "can_subst_Operand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "template": "can_subst_VecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "template": "can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})", + "fields": [ + "a0", + "a1", + "a2" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "EcxGamma", + "precedence": 100 + }, + { + "variant_name": "EcxOperandGroup", + "precedence": 100 + }, + { + "variant_name": "EcxPureOp", + "precedence": 100 + }, + { + "variant_name": "EcxShiftBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBody", + "precedence": 100 + }, + { + "variant_name": "EcxSubstBodyAll", + "precedence": 100 + }, + { + "variant_name": "EcxTheta", + "precedence": 100 + }, + { + "variant_name": "Ecxkw_const", + "precedence": 100 + }, + { + "variant_name": "EcxBril", + "precedence": 100 + }, + { + "variant_name": "EcxPrintState", + "precedence": 100 + }, + { + "variant_name": "EcxCall", + "precedence": 100 + }, + { + "variant_name": "EcxConst", + "precedence": 100 + }, + { + "variant_name": "EcxPRINT", + "precedence": 100 + }, + { + "variant_name": "EcxShiftExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExpr", + "precedence": 100 + }, + { + "variant_name": "EcxSubstExprAll", + "precedence": 100 + }, + { + "variant_name": "Ecxbadd", + "precedence": 100 + }, + { + "variant_name": "Ecxband", + "precedence": 100 + }, + { + "variant_name": "Ecxbdiv", + "precedence": 100 + }, + { + "variant_name": "Ecxbeq", + "precedence": 100 + }, + { + "variant_name": "Ecxbfmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbge", + "precedence": 100 + }, + { + "variant_name": "Ecxbgt", + "precedence": 100 + }, + { + "variant_name": "Ecxble", + "precedence": 100 + }, + { + "variant_name": "Ecxblt", + "precedence": 100 + }, + { + "variant_name": "Ecxbmul", + "precedence": 100 + }, + { + "variant_name": "Ecxbnot", + "precedence": 100 + }, + { + "variant_name": "Ecxbor", + "precedence": 100 + }, + { + "variant_name": "Ecxbsub", + "precedence": 100 + }, + { + "variant_name": "EcxFunc", + "precedence": 100 + }, + { + "variant_name": "EcxBoolI", + "precedence": 100 + }, + { + "variant_name": "EcxIntI", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_intersect", + "precedence": 100 + }, + { + "variant_name": "Ecxinterval_union", + "precedence": 100 + }, + { + "variant_name": "EcxBool", + "precedence": 100 + }, + { + "variant_name": "EcxChar", + "precedence": 100 + }, + { + "variant_name": "EcxFloat", + "precedence": 100 + }, + { + "variant_name": "EcxNum", + "precedence": 100 + }, + { + "variant_name": "EcxArg", + "precedence": 100 + }, + { + "variant_name": "EcxNode", + "precedence": 100 + }, + { + "variant_name": "EcxProject", + "precedence": 100 + }, + { + "variant_name": "EcxShiftOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxNoneType", + "precedence": 100 + }, + { + "variant_name": "EcxSomeType", + "precedence": 100 + }, + { + "variant_name": "EcxBodyAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxExprAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxSmaller", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperandAndCost", + "precedence": 100 + }, + { + "variant_name": "EcxBoolT", + "precedence": 100 + }, + { + "variant_name": "EcxCharT", + "precedence": 100 + }, + { + "variant_name": "EcxFloatT", + "precedence": 100 + }, + { + "variant_name": "EcxIntT", + "precedence": 100 + }, + { + "variant_name": "EcxPointerT", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxBodyToVecOperandHelper", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArguments", + "precedence": 100 + }, + { + "variant_name": "EcxPassThroughArgumentsHelper", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVO", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_get", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxShiftVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperand_helper", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll", + "precedence": 100 + }, + { + "variant_name": "EcxSubstVecVecOperandAll_helper", + "precedence": 100 + }, + { + "variant_name": "EcxVVO", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Body", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Expr", + "precedence": 100 + }, + { + "variant_name": "EcxBody_contains_Operand", + "precedence": 100 + }, + { + "variant_name": "EcxBody_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxExpr_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxFunction_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "EcxVecVecOperand_is_pure", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Body_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Expr_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_Operand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecOperand_beneath", + "precedence": 100 + }, + { + "variant_name": "Ecxcan_subst_VecVecOperand_beneath", + "precedence": 100 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "r0201", + "premises": [ + { + "target_id": "n1", + "label": "n1: ", + "plain_source": "n_1", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ n_1 $]" + }, + { + "target_id": "n2", + "label": "n2: ", + "plain_source": "n_2", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ n_2 $]" + }, + { + "target_id": "_t1", + "label": "_t1: Ecxbadd", + "plain_source": "upright(\"badd\")(upright(\"IntT\"), a, (upright(\"Node\")((upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), b, c)))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $])) $])) $])) $]" + }, + { + "target_id": "_t2", + "label": "_t2: EcxIntT", + "plain_source": "upright(\"IntT\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $]" + }, + { + "target_id": "_t3", + "label": "_t3: EcxNode", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), b, c)))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $])) $])) $]" + }, + { + "target_id": "_t4", + "label": "_t4: EcxPureOp", + "plain_source": "upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), b, c)))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $])) $]" + }, + { + "target_id": "_t5", + "label": "_t5: Ecxbadd", + "plain_source": "upright(\"badd\")(upright(\"IntT\"), b, c)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $]" + }, + { + "target_id": "_t6", + "label": "_t6: EcxIntT", + "plain_source": "upright(\"IntT\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $]" + }, + { + "target_id": "_t7", + "label": "_t7: EcxNode", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"_t10\"), upright(\"_t11\"), upright(\"_t12\"))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t12\") $]) $])) $])) $]" + }, + { + "target_id": "_t8", + "label": "_t8: EcxPureOp", + "plain_source": "upright(\"PureOp\")((upright(\"Const\")(upright(\"_t10\"), upright(\"_t11\"), upright(\"_t12\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t12\") $]) $])) $]" + }, + { + "target_id": "_t9", + "label": "_t9: EcxConst", + "plain_source": "upright(\"Const\")(upright(\"_t10\"), upright(\"_t11\"), upright(\"_t12\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t12\") $]) $]" + }, + { + "target_id": "_t10", + "label": "_t10: EcxIntT", + "plain_source": "upright(\"IntT\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $]" + }, + { + "target_id": "_t11", + "label": "_t11: Ecxkw_const", + "plain_source": "upright(\"kw_const\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $]" + }, + { + "target_id": "_t12", + "label": "_t12: EcxNum", + "plain_source": "upright(\"_t12\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t12\") $]" + }, + { + "target_id": "_t13", + "label": "_t13: EcxNode", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"_t16\"), upright(\"_t17\"), upright(\"_t18\"))))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t16\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t17\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t18\") $]) $])) $])) $]" + }, + { + "target_id": "_t14", + "label": "_t14: EcxPureOp", + "plain_source": "upright(\"PureOp\")((upright(\"Const\")(upright(\"_t16\"), upright(\"_t17\"), upright(\"_t18\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t16\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t17\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t18\") $]) $])) $]" + }, + { + "target_id": "_t15", + "label": "_t15: EcxConst", + "plain_source": "upright(\"Const\")(upright(\"_t16\"), upright(\"_t17\"), upright(\"_t18\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t16\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t17\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t18\") $]) $]" + }, + { + "target_id": "_t16", + "label": "_t16: EcxIntT", + "plain_source": "upright(\"IntT\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $]" + }, + { + "target_id": "_t17", + "label": "_t17: Ecxkw_const", + "plain_source": "upright(\"kw_const\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $]" + }, + { + "target_id": "_t18", + "label": "_t18: EcxNum", + "plain_source": "upright(\"_t18\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t18\") $]" + } + ], + "side_conditions": [ + "upright(\"lhs\") == upright(\"_t1\")", + "n_1 == upright(\"_t12.a0\")", + "a == upright(\"_t7\")", + "n_2 == upright(\"_t18.a0\")", + "b == upright(\"_t13\")" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "t2", + "plain_source": "upright(\"IntT\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $]" + }, + { + "target_id": "effect:effect_1", + "label": "t6", + "plain_source": "upright(\"IntT\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $]" + }, + { + "target_id": "effect:effect_2", + "label": "t7", + "plain_source": "upright(\"EcxkwConst\")()", + "colored_source": "upright(\"EcxkwConst\")()" + }, + { + "target_id": "effect:effect_3", + "label": "t8", + "plain_source": "upright(\"Num\")(n_1 + n_2)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Num\")(#text(fill: rgb(\"#B86A5B\"))[$ n_1 + n_2 $]) $]" + }, + { + "target_id": "effect:effect_4", + "label": "t5", + "plain_source": "upright(\"Const\")(upright(\"IntT\"), upright(\"EcxkwConst\")(), (upright(\"Num\")(n_1 + n_2)))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], upright(\"EcxkwConst\")(), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Num\")(#text(fill: rgb(\"#B86A5B\"))[$ n_1 + n_2 $]) $])) $]" + }, + { + "target_id": "effect:effect_5", + "label": "t4", + "plain_source": "upright(\"PureOp\")((upright(\"Const\")(upright(\"IntT\"), upright(\"EcxkwConst\")(), (upright(\"Num\")(n_1 + n_2)))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], upright(\"EcxkwConst\")(), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Num\")(#text(fill: rgb(\"#B86A5B\"))[$ n_1 + n_2 $]) $])) $])) $]" + }, + { + "target_id": "effect:effect_6", + "label": "t3", + "plain_source": "upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"IntT\"), upright(\"EcxkwConst\")(), (upright(\"Num\")(n_1 + n_2)))))))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Node\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], upright(\"EcxkwConst\")(), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Num\")(#text(fill: rgb(\"#B86A5B\"))[$ n_1 + n_2 $]) $])) $])) $])) $]" + }, + { + "target_id": "effect:effect_7", + "label": "t1", + "plain_source": "upright(\"badd\")(upright(\"IntT\"), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"IntT\"), upright(\"EcxkwConst\")(), (upright(\"Num\")(n_1 + n_2)))))))), c)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Node\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], upright(\"EcxkwConst\")(), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Num\")(#text(fill: rgb(\"#B86A5B\"))[$ n_1 + n_2 $]) $])) $])) $])) $]), #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_8", + "from": { + "target_id": "lhs", + "label": "lhs: EcxExpr", + "plain_source": "upright(\"lhs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]" + }, + "to": { + "target_id": "effect:effect_7", + "label": "t1", + "plain_source": "upright(\"badd\")(upright(\"IntT\"), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"IntT\"), upright(\"EcxkwConst\")(), (upright(\"Num\")(n_1 + n_2)))))))), c)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Node\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], upright(\"EcxkwConst\")(), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Num\")(#text(fill: rgb(\"#B86A5B\"))[$ n_1 + n_2 $]) $])) $])) $])) $]), #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(n_1 \\ n_2 \\ upright(\"badd\")(upright(\"IntT\"), a, (upright(\"Node\")((upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), b, c))))))) \\ upright(\"IntT\") \\ upright(\"Node\")((upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), b, c))))) \\ upright(\"PureOp\")((upright(\"badd\")(upright(\"IntT\"), b, c))) \\ upright(\"badd\")(upright(\"IntT\"), b, c) \\ upright(\"IntT\") \\ upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"_t10\"), upright(\"_t11\"), upright(\"_t12\")))))) \\ upright(\"PureOp\")((upright(\"Const\")(upright(\"_t10\"), upright(\"_t11\"), upright(\"_t12\")))) \\ upright(\"Const\")(upright(\"_t10\"), upright(\"_t11\"), upright(\"_t12\")) \\ upright(\"IntT\") \\ upright(\"kw_const\") \\ upright(\"_t12\") \\ upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"_t16\"), upright(\"_t17\"), upright(\"_t18\")))))) \\ upright(\"PureOp\")((upright(\"Const\")(upright(\"_t16\"), upright(\"_t17\"), upright(\"_t18\")))) \\ upright(\"Const\")(upright(\"_t16\"), upright(\"_t17\"), upright(\"_t18\")) \\ upright(\"IntT\") \\ upright(\"kw_const\") \\ upright(\"_t18\"), upright(\"lhs\") arrow.r.double upright(\"badd\")(upright(\"IntT\"), (upright(\"Node\")((upright(\"PureOp\")((upright(\"Const\")(upright(\"IntT\"), upright(\"EcxkwConst\")(), (upright(\"Num\")(n_1 + n_2)))))))), c)) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\") \\ n_1 == upright(\"_t12.a0\") \\ a == upright(\"_t7\") \\ n_2 == upright(\"_t18.a0\") \\ b == upright(\"_t13\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ n_1 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ n_2 $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ a $], (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $])) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"badd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $], #text(fill: rgb(\"#5F7A8A\"))[$ b $], #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t12\") $]) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t12\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t10\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t11\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t12\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t12\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Node\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t16\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t17\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t18\") $]) $])) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t16\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t17\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t18\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Const\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t16\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t17\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t18\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"IntT\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"kw_const\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"_t18\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"badd\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Node\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"PureOp\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"IntT\") $], upright(\"EcxkwConst\")(), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"Num\")(#text(fill: rgb(\"#B86A5B\"))[$ n_1 + n_2 $]) $])) $])) $])) $]), #text(fill: rgb(\"#5F7A8A\"))[$ c $]) $]) quad upright(\"if\") quad upright(\"lhs\") == upright(\"_t1\") \\ n_1 == upright(\"_t12.a0\") \\ a == upright(\"_t7\") \\ n_2 == upright(\"_t18.a0\") \\ b == upright(\"_t13\")" + } + } + } + }, + { + "id": "benches_runners_generated_taylor51_rs__102_5_MyTxTaylor51_add_rule__taylor51_seed__e341c7e3250453ae", + "display_name": "taylor51_seed", + "rule_name": "taylor51_seed", + "callee": "MyTxTaylor51::add_rule", + "file": "benches/runners/generated/taylor51.rs", + "offset": 2992, + "line": 102, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 2992, + "end": 148889 + }, + "pattern_range": { + "start": 3063, + "end": 3144 + }, + "action_range": { + "start": 3154, + "end": 148882 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Unit" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@3189:3223", + "bound_var": "sR", + "source_text": "ctx.insert_t51_var(\"R\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 3189, + "end": 3223 + } + }, + { + "id": "effect_1", + "effect_id": "effect@3252:3292", + "bound_var": "slambda1", + "source_text": "ctx.insert_t51_var(\"lambda1\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 3252, + "end": 3292 + } + }, + { + "id": "effect_2", + "effect_id": "effect@3321:3361", + "bound_var": "slambda2", + "source_text": "ctx.insert_t51_var(\"lambda2\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 3321, + "end": 3361 + } + }, + { + "id": "effect_3", + "effect_id": "effect@3387:3424", + "bound_var": "sphi1", + "source_text": "ctx.insert_t51_var(\"phi1\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 3387, + "end": 3424 + } + }, + { + "id": "effect_4", + "effect_id": "effect@3450:3487", + "bound_var": "sphi2", + "source_text": "ctx.insert_t51_var(\"phi2\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 3450, + "end": 3487 + } + }, + { + "id": "effect_5", + "effect_id": "effect@3510:3552", + "bound_var": "tR", + "source_text": "ctx.insert_t51_varbinary64(\"R\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 3510, + "end": 3552 + } + }, + { + "id": "effect_6", + "effect_id": "effect@3581:3629", + "bound_var": "tlambda1", + "source_text": "ctx.insert_t51_varbinary64(\"lambda1\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 3581, + "end": 3629 + } + }, + { + "id": "effect_7", + "effect_id": "effect@3658:3706", + "bound_var": "tlambda2", + "source_text": "ctx.insert_t51_varbinary64(\"lambda2\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 3658, + "end": 3706 + } + }, + { + "id": "effect_8", + "effect_id": "effect@3732:3777", + "bound_var": "tphi1", + "source_text": "ctx.insert_t51_varbinary64(\"phi1\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 3732, + "end": 3777 + } + }, + { + "id": "effect_9", + "effect_id": "effect@3803:3848", + "bound_var": "tphi2", + "source_text": "ctx.insert_t51_varbinary64(\"phi2\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 3803, + "end": 3848 + } + }, + { + "id": "effect_10", + "effect_id": "effect@3871:3907", + "bound_var": "b1", + "source_text": "ctx.insert_t51_num(\"0/1\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 3871, + "end": 3907 + } + }, + { + "id": "effect_11", + "effect_id": "effect@3930:3985", + "bound_var": "b2", + "source_text": "ctx.insert_t51_lower(b1.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1" + ], + "range": { + "start": 3930, + "end": 3985 + } + }, + { + "id": "effect_12", + "effect_id": "effect@4008:4056", + "bound_var": "r3", + "source_text": "ctx.insert_t51_approx(sphi1.clone(), b2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b2", + "sphi1" + ], + "range": { + "start": 4008, + "end": 4056 + } + }, + { + "id": "effect_13", + "effect_id": "effect@4070:4104", + "bound_var": null, + "source_text": "ctx.set_to_extract(13, r3.clone())", + "semantic_text": "to_extract(13) = r3", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r3" + ], + "range": { + "start": 4070, + "end": 4104 + } + }, + { + "id": "effect_14", + "effect_id": "effect@4127:4182", + "bound_var": "b5", + "source_text": "ctx.insert_t51_lower(sR.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "sR" + ], + "range": { + "start": 4127, + "end": 4182 + } + }, + { + "id": "effect_15", + "effect_id": "effect@4205:4250", + "bound_var": "r6", + "source_text": "ctx.insert_t51_approx(sR.clone(), b5.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b5", + "sR" + ], + "range": { + "start": 4205, + "end": 4250 + } + }, + { + "id": "effect_16", + "effect_id": "effect@4264:4298", + "bound_var": null, + "source_text": "ctx.set_to_extract(15, r6.clone())", + "semantic_text": "to_extract(15) = r6", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r6" + ], + "range": { + "start": 4264, + "end": 4298 + } + }, + { + "id": "effect_17", + "effect_id": "effect@4321:4354", + "bound_var": "b7", + "source_text": "ctx.insert_t51_sin(sphi1.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "sphi1" + ], + "range": { + "start": 4321, + "end": 4354 + } + }, + { + "id": "effect_18", + "effect_id": "effect@4377:4410", + "bound_var": "b9", + "source_text": "ctx.insert_t51_sin(sphi2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "sphi2" + ], + "range": { + "start": 4377, + "end": 4410 + } + }, + { + "id": "effect_19", + "effect_id": "effect@4434:4476", + "bound_var": "b10", + "source_text": "ctx.insert_t51_mul(b7.clone(), b9.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b7", + "b9" + ], + "range": { + "start": 4434, + "end": 4476 + } + }, + { + "id": "effect_20", + "effect_id": "effect@4500:4533", + "bound_var": "b11", + "source_text": "ctx.insert_t51_cos(sphi1.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "sphi1" + ], + "range": { + "start": 4500, + "end": 4533 + } + }, + { + "id": "effect_21", + "effect_id": "effect@4557:4590", + "bound_var": "b12", + "source_text": "ctx.insert_t51_cos(sphi2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "sphi2" + ], + "range": { + "start": 4557, + "end": 4590 + } + }, + { + "id": "effect_22", + "effect_id": "effect@4614:4658", + "bound_var": "b13", + "source_text": "ctx.insert_t51_mul(b11.clone(), b12.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b11", + "b12" + ], + "range": { + "start": 4614, + "end": 4658 + } + }, + { + "id": "effect_23", + "effect_id": "effect@4682:4736", + "bound_var": "b16", + "source_text": "ctx.insert_t51_sub(slambda1.clone(), slambda2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "slambda1", + "slambda2" + ], + "range": { + "start": 4682, + "end": 4736 + } + }, + { + "id": "effect_24", + "effect_id": "effect@4760:4791", + "bound_var": "b17", + "source_text": "ctx.insert_t51_cos(b16.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b16" + ], + "range": { + "start": 4760, + "end": 4791 + } + }, + { + "id": "effect_25", + "effect_id": "effect@4815:4859", + "bound_var": "b18", + "source_text": "ctx.insert_t51_mul(b13.clone(), b17.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b13", + "b17" + ], + "range": { + "start": 4815, + "end": 4859 + } + }, + { + "id": "effect_26", + "effect_id": "effect@4883:4927", + "bound_var": "b19", + "source_text": "ctx.insert_t51_add(b10.clone(), b18.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b10", + "b18" + ], + "range": { + "start": 4883, + "end": 4927 + } + }, + { + "id": "effect_27", + "effect_id": "effect@4951:4983", + "bound_var": "b20", + "source_text": "ctx.insert_t51_acos(b19.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b19" + ], + "range": { + "start": 4951, + "end": 4983 + } + }, + { + "id": "effect_28", + "effect_id": "effect@5007:5050", + "bound_var": "b21", + "source_text": "ctx.insert_t51_mul(b20.clone(), sR.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b20", + "sR" + ], + "range": { + "start": 5007, + "end": 5050 + } + }, + { + "id": "effect_29", + "effect_id": "effect@5074:5118", + "bound_var": "b22", + "source_text": "ctx.insert_t51_mul(b12.clone(), b17.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b12", + "b17" + ], + "range": { + "start": 5074, + "end": 5118 + } + }, + { + "id": "effect_30", + "effect_id": "effect@5142:5186", + "bound_var": "b23", + "source_text": "ctx.insert_t51_mul(b11.clone(), b22.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b11", + "b22" + ], + "range": { + "start": 5142, + "end": 5186 + } + }, + { + "id": "effect_31", + "effect_id": "effect@5210:5254", + "bound_var": "b24", + "source_text": "ctx.insert_t51_add(b23.clone(), b10.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b10", + "b23" + ], + "range": { + "start": 5210, + "end": 5254 + } + }, + { + "id": "effect_32", + "effect_id": "effect@5278:5310", + "bound_var": "b25", + "source_text": "ctx.insert_t51_acos(b24.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b24" + ], + "range": { + "start": 5278, + "end": 5310 + } + }, + { + "id": "effect_33", + "effect_id": "effect@5334:5377", + "bound_var": "b26", + "source_text": "ctx.insert_t51_mul(sR.clone(), b25.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b25", + "sR" + ], + "range": { + "start": 5334, + "end": 5377 + } + }, + { + "id": "effect_34", + "effect_id": "effect@5401:5457", + "bound_var": "b27", + "source_text": "ctx.insert_t51_lower(b26.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b26" + ], + "range": { + "start": 5401, + "end": 5457 + } + }, + { + "id": "effect_35", + "effect_id": "effect@5481:5528", + "bound_var": "r28", + "source_text": "ctx.insert_t51_approx(b21.clone(), b27.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b21", + "b27" + ], + "range": { + "start": 5481, + "end": 5528 + } + }, + { + "id": "effect_36", + "effect_id": "effect@5542:5577", + "bound_var": null, + "source_text": "ctx.set_to_extract(34, r28.clone())", + "semantic_text": "to_extract(34) = r28", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r28" + ], + "range": { + "start": 5542, + "end": 5577 + } + }, + { + "id": "effect_37", + "effect_id": "effect@5601:5637", + "bound_var": "b29", + "source_text": "ctx.insert_t51_cos(slambda1.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "slambda1" + ], + "range": { + "start": 5601, + "end": 5637 + } + }, + { + "id": "effect_38", + "effect_id": "effect@5661:5697", + "bound_var": "b30", + "source_text": "ctx.insert_t51_cos(slambda2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "slambda2" + ], + "range": { + "start": 5661, + "end": 5697 + } + }, + { + "id": "effect_39", + "effect_id": "effect@5721:5765", + "bound_var": "b31", + "source_text": "ctx.insert_t51_mul(b29.clone(), b30.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b29", + "b30" + ], + "range": { + "start": 5721, + "end": 5765 + } + }, + { + "id": "effect_40", + "effect_id": "effect@5789:5825", + "bound_var": "b32", + "source_text": "ctx.insert_t51_sin(slambda1.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "slambda1" + ], + "range": { + "start": 5789, + "end": 5825 + } + }, + { + "id": "effect_41", + "effect_id": "effect@5849:5885", + "bound_var": "b33", + "source_text": "ctx.insert_t51_sin(slambda2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "slambda2" + ], + "range": { + "start": 5849, + "end": 5885 + } + }, + { + "id": "effect_42", + "effect_id": "effect@5909:5953", + "bound_var": "b34", + "source_text": "ctx.insert_t51_mul(b32.clone(), b33.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b32", + "b33" + ], + "range": { + "start": 5909, + "end": 5953 + } + }, + { + "id": "effect_43", + "effect_id": "effect@5977:6021", + "bound_var": "b35", + "source_text": "ctx.insert_t51_add(b31.clone(), b34.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b31", + "b34" + ], + "range": { + "start": 5977, + "end": 6021 + } + }, + { + "id": "effect_44", + "effect_id": "effect@6045:6089", + "bound_var": "b36", + "source_text": "ctx.insert_t51_mul(b13.clone(), b35.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b13", + "b35" + ], + "range": { + "start": 6045, + "end": 6089 + } + }, + { + "id": "effect_45", + "effect_id": "effect@6113:6157", + "bound_var": "b37", + "source_text": "ctx.insert_t51_add(b10.clone(), b36.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b10", + "b36" + ], + "range": { + "start": 6113, + "end": 6157 + } + }, + { + "id": "effect_46", + "effect_id": "effect@6181:6213", + "bound_var": "b38", + "source_text": "ctx.insert_t51_acos(b37.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b37" + ], + "range": { + "start": 6181, + "end": 6213 + } + }, + { + "id": "effect_47", + "effect_id": "effect@6237:6280", + "bound_var": "b39", + "source_text": "ctx.insert_t51_mul(b38.clone(), sR.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b38", + "sR" + ], + "range": { + "start": 6237, + "end": 6280 + } + }, + { + "id": "effect_48", + "effect_id": "effect@6304:6348", + "bound_var": "b40", + "source_text": "ctx.insert_t51_mul(b12.clone(), b35.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b12", + "b35" + ], + "range": { + "start": 6304, + "end": 6348 + } + }, + { + "id": "effect_49", + "effect_id": "effect@6372:6416", + "bound_var": "b41", + "source_text": "ctx.insert_t51_mul(b11.clone(), b40.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b11", + "b40" + ], + "range": { + "start": 6372, + "end": 6416 + } + }, + { + "id": "effect_50", + "effect_id": "effect@6440:6484", + "bound_var": "b42", + "source_text": "ctx.insert_t51_add(b41.clone(), b10.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b10", + "b41" + ], + "range": { + "start": 6440, + "end": 6484 + } + }, + { + "id": "effect_51", + "effect_id": "effect@6508:6540", + "bound_var": "b43", + "source_text": "ctx.insert_t51_acos(b42.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b42" + ], + "range": { + "start": 6508, + "end": 6540 + } + }, + { + "id": "effect_52", + "effect_id": "effect@6564:6607", + "bound_var": "b44", + "source_text": "ctx.insert_t51_mul(sR.clone(), b43.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b43", + "sR" + ], + "range": { + "start": 6564, + "end": 6607 + } + }, + { + "id": "effect_53", + "effect_id": "effect@6631:6687", + "bound_var": "b45", + "source_text": "ctx.insert_t51_lower(b44.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b44" + ], + "range": { + "start": 6631, + "end": 6687 + } + }, + { + "id": "effect_54", + "effect_id": "effect@6711:6758", + "bound_var": "r46", + "source_text": "ctx.insert_t51_approx(b39.clone(), b45.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b39", + "b45" + ], + "range": { + "start": 6711, + "end": 6758 + } + }, + { + "id": "effect_55", + "effect_id": "effect@6772:6807", + "bound_var": null, + "source_text": "ctx.set_to_extract(52, r46.clone())", + "semantic_text": "to_extract(52) = r46", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r46" + ], + "range": { + "start": 6772, + "end": 6807 + } + }, + { + "id": "effect_56", + "effect_id": "effect@6831:6892", + "bound_var": "b47", + "source_text": "ctx.insert_t51_lower(slambda1.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "slambda1" + ], + "range": { + "start": 6831, + "end": 6892 + } + }, + { + "id": "effect_57", + "effect_id": "effect@6916:6968", + "bound_var": "r48", + "source_text": "ctx.insert_t51_approx(slambda1.clone(), b47.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b47", + "slambda1" + ], + "range": { + "start": 6916, + "end": 6968 + } + }, + { + "id": "effect_58", + "effect_id": "effect@6982:7017", + "bound_var": null, + "source_text": "ctx.set_to_extract(54, r48.clone())", + "semantic_text": "to_extract(54) = r48", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r48" + ], + "range": { + "start": 6982, + "end": 7017 + } + }, + { + "id": "effect_59", + "effect_id": "effect@7041:7078", + "bound_var": "b49", + "source_text": "ctx.insert_t51_num(\"-1/1\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 7041, + "end": 7078 + } + }, + { + "id": "effect_60", + "effect_id": "effect@7102:7151", + "bound_var": "b50", + "source_text": "ctx.insert_t51_mul(b49.clone(), slambda2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b49", + "slambda2" + ], + "range": { + "start": 7102, + "end": 7151 + } + }, + { + "id": "effect_61", + "effect_id": "effect@7175:7231", + "bound_var": "b51", + "source_text": "ctx.insert_t51_lower(b50.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b50" + ], + "range": { + "start": 7175, + "end": 7231 + } + }, + { + "id": "effect_62", + "effect_id": "effect@7255:7302", + "bound_var": "r52", + "source_text": "ctx.insert_t51_approx(b16.clone(), b51.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b16", + "b51" + ], + "range": { + "start": 7255, + "end": 7302 + } + }, + { + "id": "effect_63", + "effect_id": "effect@7316:7351", + "bound_var": null, + "source_text": "ctx.set_to_extract(58, r52.clone())", + "semantic_text": "to_extract(58) = r52", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r52" + ], + "range": { + "start": 7316, + "end": 7351 + } + }, + { + "id": "effect_64", + "effect_id": "effect@7375:7431", + "bound_var": "b53", + "source_text": "ctx.insert_t51_lower(b16.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b16" + ], + "range": { + "start": 7375, + "end": 7431 + } + }, + { + "id": "effect_65", + "effect_id": "effect@7455:7502", + "bound_var": "r54", + "source_text": "ctx.insert_t51_approx(b16.clone(), b53.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b16", + "b53" + ], + "range": { + "start": 7455, + "end": 7502 + } + }, + { + "id": "effect_66", + "effect_id": "effect@7516:7551", + "bound_var": null, + "source_text": "ctx.set_to_extract(60, r54.clone())", + "semantic_text": "to_extract(60) = r54", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r54" + ], + "range": { + "start": 7516, + "end": 7551 + } + }, + { + "id": "effect_67", + "effect_id": "effect@7575:7611", + "bound_var": "b55", + "source_text": "ctx.insert_t51_neg(slambda2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "slambda2" + ], + "range": { + "start": 7575, + "end": 7611 + } + }, + { + "id": "effect_68", + "effect_id": "effect@7635:7666", + "bound_var": "b56", + "source_text": "ctx.insert_t51_cos(b55.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b55" + ], + "range": { + "start": 7635, + "end": 7666 + } + }, + { + "id": "effect_69", + "effect_id": "effect@7690:7746", + "bound_var": "b57", + "source_text": "ctx.insert_t51_lower(b56.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b56" + ], + "range": { + "start": 7690, + "end": 7746 + } + }, + { + "id": "effect_70", + "effect_id": "effect@7770:7817", + "bound_var": "r58", + "source_text": "ctx.insert_t51_approx(b17.clone(), b57.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b17", + "b57" + ], + "range": { + "start": 7770, + "end": 7817 + } + }, + { + "id": "effect_71", + "effect_id": "effect@7831:7866", + "bound_var": null, + "source_text": "ctx.set_to_extract(64, r58.clone())", + "semantic_text": "to_extract(64) = r58", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r58" + ], + "range": { + "start": 7831, + "end": 7866 + } + }, + { + "id": "effect_72", + "effect_id": "effect@7890:7921", + "bound_var": "b59", + "source_text": "ctx.insert_t51_sin(b55.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b55" + ], + "range": { + "start": 7890, + "end": 7921 + } + }, + { + "id": "effect_73", + "effect_id": "effect@7945:7994", + "bound_var": "b60", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b59.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b59", + "slambda1" + ], + "range": { + "start": 7945, + "end": 7994 + } + }, + { + "id": "effect_74", + "effect_id": "effect@8018:8062", + "bound_var": "b61", + "source_text": "ctx.insert_t51_mul(b49.clone(), b60.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b49", + "b60" + ], + "range": { + "start": 8018, + "end": 8062 + } + }, + { + "id": "effect_75", + "effect_id": "effect@8086:8130", + "bound_var": "b62", + "source_text": "ctx.insert_t51_add(b56.clone(), b61.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b56", + "b61" + ], + "range": { + "start": 8086, + "end": 8130 + } + }, + { + "id": "effect_76", + "effect_id": "effect@8154:8210", + "bound_var": "b63", + "source_text": "ctx.insert_t51_lower(b62.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b62" + ], + "range": { + "start": 8154, + "end": 8210 + } + }, + { + "id": "effect_77", + "effect_id": "effect@8234:8281", + "bound_var": "r64", + "source_text": "ctx.insert_t51_approx(b17.clone(), b63.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b17", + "b63" + ], + "range": { + "start": 8234, + "end": 8281 + } + }, + { + "id": "effect_78", + "effect_id": "effect@8295:8330", + "bound_var": null, + "source_text": "ctx.set_to_extract(70, r64.clone())", + "semantic_text": "to_extract(70) = r64", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r64" + ], + "range": { + "start": 8295, + "end": 8330 + } + }, + { + "id": "effect_79", + "effect_id": "effect@8354:8391", + "bound_var": "b65", + "source_text": "ctx.insert_t51_num(\"-1/2\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 8354, + "end": 8391 + } + }, + { + "id": "effect_80", + "effect_id": "effect@8415:8464", + "bound_var": "b66", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b56.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b56", + "slambda1" + ], + "range": { + "start": 8415, + "end": 8464 + } + }, + { + "id": "effect_81", + "effect_id": "effect@8488:8532", + "bound_var": "b67", + "source_text": "ctx.insert_t51_mul(b65.clone(), b66.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b65", + "b66" + ], + "range": { + "start": 8488, + "end": 8532 + } + }, + { + "id": "effect_82", + "effect_id": "effect@8556:8600", + "bound_var": "b68", + "source_text": "ctx.insert_t51_sub(b67.clone(), b59.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b59", + "b67" + ], + "range": { + "start": 8556, + "end": 8600 + } + }, + { + "id": "effect_83", + "effect_id": "effect@8624:8673", + "bound_var": "b69", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b68.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b68", + "slambda1" + ], + "range": { + "start": 8624, + "end": 8673 + } + }, + { + "id": "effect_84", + "effect_id": "effect@8697:8741", + "bound_var": "b70", + "source_text": "ctx.insert_t51_add(b56.clone(), b69.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b56", + "b69" + ], + "range": { + "start": 8697, + "end": 8741 + } + }, + { + "id": "effect_85", + "effect_id": "effect@8765:8821", + "bound_var": "b71", + "source_text": "ctx.insert_t51_lower(b70.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b70" + ], + "range": { + "start": 8765, + "end": 8821 + } + }, + { + "id": "effect_86", + "effect_id": "effect@8845:8892", + "bound_var": "r72", + "source_text": "ctx.insert_t51_approx(b17.clone(), b71.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b17", + "b71" + ], + "range": { + "start": 8845, + "end": 8892 + } + }, + { + "id": "effect_87", + "effect_id": "effect@8906:8941", + "bound_var": null, + "source_text": "ctx.set_to_extract(78, r72.clone())", + "semantic_text": "to_extract(78) = r72", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r72" + ], + "range": { + "start": 8906, + "end": 8941 + } + }, + { + "id": "effect_88", + "effect_id": "effect@8965:9009", + "bound_var": "b73", + "source_text": "ctx.insert_t51_mul(b65.clone(), b56.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b56", + "b65" + ], + "range": { + "start": 8965, + "end": 9009 + } + }, + { + "id": "effect_89", + "effect_id": "effect@9033:9069", + "bound_var": "b74", + "source_text": "ctx.insert_t51_num(\"1/6\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 9033, + "end": 9069 + } + }, + { + "id": "effect_90", + "effect_id": "effect@9093:9137", + "bound_var": "b75", + "source_text": "ctx.insert_t51_mul(b74.clone(), b60.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b60", + "b74" + ], + "range": { + "start": 9093, + "end": 9137 + } + }, + { + "id": "effect_91", + "effect_id": "effect@9161:9205", + "bound_var": "b76", + "source_text": "ctx.insert_t51_add(b73.clone(), b75.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b73", + "b75" + ], + "range": { + "start": 9161, + "end": 9205 + } + }, + { + "id": "effect_92", + "effect_id": "effect@9229:9278", + "bound_var": "b77", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b76.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b76", + "slambda1" + ], + "range": { + "start": 9229, + "end": 9278 + } + }, + { + "id": "effect_93", + "effect_id": "effect@9302:9346", + "bound_var": "b78", + "source_text": "ctx.insert_t51_sub(b77.clone(), b59.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b59", + "b77" + ], + "range": { + "start": 9302, + "end": 9346 + } + }, + { + "id": "effect_94", + "effect_id": "effect@9370:9419", + "bound_var": "b79", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b78.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b78", + "slambda1" + ], + "range": { + "start": 9370, + "end": 9419 + } + }, + { + "id": "effect_95", + "effect_id": "effect@9443:9487", + "bound_var": "b80", + "source_text": "ctx.insert_t51_add(b56.clone(), b79.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b56", + "b79" + ], + "range": { + "start": 9443, + "end": 9487 + } + }, + { + "id": "effect_96", + "effect_id": "effect@9511:9567", + "bound_var": "b81", + "source_text": "ctx.insert_t51_lower(b80.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b80" + ], + "range": { + "start": 9511, + "end": 9567 + } + }, + { + "id": "effect_97", + "effect_id": "effect@9591:9638", + "bound_var": "r82", + "source_text": "ctx.insert_t51_approx(b17.clone(), b81.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b17", + "b81" + ], + "range": { + "start": 9591, + "end": 9638 + } + }, + { + "id": "effect_98", + "effect_id": "effect@9652:9687", + "bound_var": null, + "source_text": "ctx.set_to_extract(88, r82.clone())", + "semantic_text": "to_extract(88) = r82", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r82" + ], + "range": { + "start": 9652, + "end": 9687 + } + }, + { + "id": "effect_99", + "effect_id": "effect@9711:9767", + "bound_var": "b83", + "source_text": "ctx.insert_t51_lower(b60.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b60" + ], + "range": { + "start": 9711, + "end": 9767 + } + }, + { + "id": "effect_100", + "effect_id": "effect@9791:9838", + "bound_var": "r84", + "source_text": "ctx.insert_t51_approx(b60.clone(), b83.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b60", + "b83" + ], + "range": { + "start": 9791, + "end": 9838 + } + }, + { + "id": "effect_101", + "effect_id": "effect@9852:9887", + "bound_var": null, + "source_text": "ctx.set_to_extract(90, r84.clone())", + "semantic_text": "to_extract(90) = r84", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r84" + ], + "range": { + "start": 9852, + "end": 9887 + } + }, + { + "id": "effect_102", + "effect_id": "effect@9911:9967", + "bound_var": "b85", + "source_text": "ctx.insert_t51_lower(b61.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b61" + ], + "range": { + "start": 9911, + "end": 9967 + } + }, + { + "id": "effect_103", + "effect_id": "effect@9991:10038", + "bound_var": "r86", + "source_text": "ctx.insert_t51_approx(b61.clone(), b85.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b61", + "b85" + ], + "range": { + "start": 9991, + "end": 10038 + } + }, + { + "id": "effect_104", + "effect_id": "effect@10052:10087", + "bound_var": null, + "source_text": "ctx.set_to_extract(92, r86.clone())", + "semantic_text": "to_extract(92) = r86", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r86" + ], + "range": { + "start": 10052, + "end": 10087 + } + }, + { + "id": "effect_105", + "effect_id": "effect@10111:10147", + "bound_var": "b87", + "source_text": "ctx.insert_t51_num(\"1/1\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 10111, + "end": 10147 + } + }, + { + "id": "effect_106", + "effect_id": "effect@10171:10227", + "bound_var": "b88", + "source_text": "ctx.insert_t51_lower(b87.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b87" + ], + "range": { + "start": 10171, + "end": 10227 + } + }, + { + "id": "effect_107", + "effect_id": "effect@10251:10298", + "bound_var": "r89", + "source_text": "ctx.insert_t51_approx(b29.clone(), b88.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b29", + "b88" + ], + "range": { + "start": 10251, + "end": 10298 + } + }, + { + "id": "effect_108", + "effect_id": "effect@10312:10347", + "bound_var": null, + "source_text": "ctx.set_to_extract(95, r89.clone())", + "semantic_text": "to_extract(95) = r89", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r89" + ], + "range": { + "start": 10312, + "end": 10347 + } + }, + { + "id": "effect_109", + "effect_id": "effect@10371:10407", + "bound_var": "b90", + "source_text": "ctx.insert_t51_num(\"2/1\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 10371, + "end": 10407 + } + }, + { + "id": "effect_110", + "effect_id": "effect@10431:10480", + "bound_var": "b91", + "source_text": "ctx.insert_t51_pow(slambda1.clone(), b90.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b90", + "slambda1" + ], + "range": { + "start": 10431, + "end": 10480 + } + }, + { + "id": "effect_111", + "effect_id": "effect@10504:10548", + "bound_var": "b92", + "source_text": "ctx.insert_t51_mul(b65.clone(), b91.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b65", + "b91" + ], + "range": { + "start": 10504, + "end": 10548 + } + }, + { + "id": "effect_112", + "effect_id": "effect@10572:10616", + "bound_var": "b93", + "source_text": "ctx.insert_t51_add(b87.clone(), b92.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b87", + "b92" + ], + "range": { + "start": 10572, + "end": 10616 + } + }, + { + "id": "effect_113", + "effect_id": "effect@10640:10696", + "bound_var": "b94", + "source_text": "ctx.insert_t51_lower(b93.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b93" + ], + "range": { + "start": 10640, + "end": 10696 + } + }, + { + "id": "effect_114", + "effect_id": "effect@10720:10767", + "bound_var": "r95", + "source_text": "ctx.insert_t51_approx(b29.clone(), b94.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b29", + "b94" + ], + "range": { + "start": 10720, + "end": 10767 + } + }, + { + "id": "effect_115", + "effect_id": "effect@10781:10817", + "bound_var": null, + "source_text": "ctx.set_to_extract(101, r95.clone())", + "semantic_text": "to_extract(101) = r95", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r95" + ], + "range": { + "start": 10781, + "end": 10817 + } + }, + { + "id": "effect_116", + "effect_id": "effect@10841:10878", + "bound_var": "b96", + "source_text": "ctx.insert_t51_num(\"1/24\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 10841, + "end": 10878 + } + }, + { + "id": "effect_117", + "effect_id": "effect@10902:10946", + "bound_var": "b97", + "source_text": "ctx.insert_t51_mul(b96.clone(), b91.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b91", + "b96" + ], + "range": { + "start": 10902, + "end": 10946 + } + }, + { + "id": "effect_118", + "effect_id": "effect@10970:11006", + "bound_var": "b98", + "source_text": "ctx.insert_t51_num(\"1/2\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 10970, + "end": 11006 + } + }, + { + "id": "effect_119", + "effect_id": "effect@11030:11074", + "bound_var": "b99", + "source_text": "ctx.insert_t51_sub(b97.clone(), b98.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b97", + "b98" + ], + "range": { + "start": 11030, + "end": 11074 + } + }, + { + "id": "effect_120", + "effect_id": "effect@11099:11143", + "bound_var": "b100", + "source_text": "ctx.insert_t51_mul(b91.clone(), b99.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b91", + "b99" + ], + "range": { + "start": 11099, + "end": 11143 + } + }, + { + "id": "effect_121", + "effect_id": "effect@11168:11213", + "bound_var": "b101", + "source_text": "ctx.insert_t51_add(b87.clone(), b100.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b100", + "b87" + ], + "range": { + "start": 11168, + "end": 11213 + } + }, + { + "id": "effect_122", + "effect_id": "effect@11238:11295", + "bound_var": "b102", + "source_text": "ctx.insert_t51_lower(b101.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b101" + ], + "range": { + "start": 11238, + "end": 11295 + } + }, + { + "id": "effect_123", + "effect_id": "effect@11320:11368", + "bound_var": "r103", + "source_text": "ctx.insert_t51_approx(b29.clone(), b102.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b102", + "b29" + ], + "range": { + "start": 11320, + "end": 11368 + } + }, + { + "id": "effect_124", + "effect_id": "effect@11382:11419", + "bound_var": null, + "source_text": "ctx.set_to_extract(109, r103.clone())", + "semantic_text": "to_extract(109) = r103", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r103" + ], + "range": { + "start": 11382, + "end": 11419 + } + }, + { + "id": "effect_125", + "effect_id": "effect@11444:11483", + "bound_var": "b104", + "source_text": "ctx.insert_t51_num(\"-1/720\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 11444, + "end": 11483 + } + }, + { + "id": "effect_126", + "effect_id": "effect@11508:11553", + "bound_var": "b105", + "source_text": "ctx.insert_t51_mul(b104.clone(), b91.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b104", + "b91" + ], + "range": { + "start": 11508, + "end": 11553 + } + }, + { + "id": "effect_127", + "effect_id": "effect@11578:11623", + "bound_var": "b106", + "source_text": "ctx.insert_t51_add(b96.clone(), b105.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b105", + "b96" + ], + "range": { + "start": 11578, + "end": 11623 + } + }, + { + "id": "effect_128", + "effect_id": "effect@11648:11693", + "bound_var": "b107", + "source_text": "ctx.insert_t51_mul(b91.clone(), b106.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b106", + "b91" + ], + "range": { + "start": 11648, + "end": 11693 + } + }, + { + "id": "effect_129", + "effect_id": "effect@11718:11763", + "bound_var": "b108", + "source_text": "ctx.insert_t51_sub(b107.clone(), b98.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b107", + "b98" + ], + "range": { + "start": 11718, + "end": 11763 + } + }, + { + "id": "effect_130", + "effect_id": "effect@11788:11833", + "bound_var": "b109", + "source_text": "ctx.insert_t51_mul(b91.clone(), b108.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b108", + "b91" + ], + "range": { + "start": 11788, + "end": 11833 + } + }, + { + "id": "effect_131", + "effect_id": "effect@11858:11903", + "bound_var": "b110", + "source_text": "ctx.insert_t51_add(b87.clone(), b109.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b109", + "b87" + ], + "range": { + "start": 11858, + "end": 11903 + } + }, + { + "id": "effect_132", + "effect_id": "effect@11928:11985", + "bound_var": "b111", + "source_text": "ctx.insert_t51_lower(b110.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b110" + ], + "range": { + "start": 11928, + "end": 11985 + } + }, + { + "id": "effect_133", + "effect_id": "effect@12010:12058", + "bound_var": "r112", + "source_text": "ctx.insert_t51_approx(b29.clone(), b111.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b111", + "b29" + ], + "range": { + "start": 12010, + "end": 12058 + } + }, + { + "id": "effect_134", + "effect_id": "effect@12072:12109", + "bound_var": null, + "source_text": "ctx.set_to_extract(118, r112.clone())", + "semantic_text": "to_extract(118) = r112", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r112" + ], + "range": { + "start": 12072, + "end": 12109 + } + }, + { + "id": "effect_135", + "effect_id": "effect@12134:12171", + "bound_var": "b113", + "source_text": "ctx.insert_t51_num(\"-1/6\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 12134, + "end": 12171 + } + }, + { + "id": "effect_136", + "effect_id": "effect@12196:12241", + "bound_var": "b114", + "source_text": "ctx.insert_t51_mul(b113.clone(), b91.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b91" + ], + "range": { + "start": 12196, + "end": 12241 + } + }, + { + "id": "effect_137", + "effect_id": "effect@12266:12311", + "bound_var": "b115", + "source_text": "ctx.insert_t51_add(b87.clone(), b114.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b114", + "b87" + ], + "range": { + "start": 12266, + "end": 12311 + } + }, + { + "id": "effect_138", + "effect_id": "effect@12336:12386", + "bound_var": "b116", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b115.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b115", + "slambda1" + ], + "range": { + "start": 12336, + "end": 12386 + } + }, + { + "id": "effect_139", + "effect_id": "effect@12411:12468", + "bound_var": "b117", + "source_text": "ctx.insert_t51_lower(b116.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b116" + ], + "range": { + "start": 12411, + "end": 12468 + } + }, + { + "id": "effect_140", + "effect_id": "effect@12493:12541", + "bound_var": "r118", + "source_text": "ctx.insert_t51_approx(b32.clone(), b117.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b117", + "b32" + ], + "range": { + "start": 12493, + "end": 12541 + } + }, + { + "id": "effect_141", + "effect_id": "effect@12555:12592", + "bound_var": null, + "source_text": "ctx.set_to_extract(124, r118.clone())", + "semantic_text": "to_extract(124) = r118", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r118" + ], + "range": { + "start": 12555, + "end": 12592 + } + }, + { + "id": "effect_142", + "effect_id": "effect@12617:12655", + "bound_var": "b119", + "source_text": "ctx.insert_t51_num(\"1/120\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 12617, + "end": 12655 + } + }, + { + "id": "effect_143", + "effect_id": "effect@12680:12725", + "bound_var": "b120", + "source_text": "ctx.insert_t51_mul(b119.clone(), b91.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b119", + "b91" + ], + "range": { + "start": 12680, + "end": 12725 + } + }, + { + "id": "effect_144", + "effect_id": "effect@12750:12795", + "bound_var": "b121", + "source_text": "ctx.insert_t51_sub(b120.clone(), b74.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b120", + "b74" + ], + "range": { + "start": 12750, + "end": 12795 + } + }, + { + "id": "effect_145", + "effect_id": "effect@12820:12865", + "bound_var": "b122", + "source_text": "ctx.insert_t51_mul(b91.clone(), b121.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b121", + "b91" + ], + "range": { + "start": 12820, + "end": 12865 + } + }, + { + "id": "effect_146", + "effect_id": "effect@12890:12935", + "bound_var": "b123", + "source_text": "ctx.insert_t51_add(b87.clone(), b122.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b122", + "b87" + ], + "range": { + "start": 12890, + "end": 12935 + } + }, + { + "id": "effect_147", + "effect_id": "effect@12960:13010", + "bound_var": "b124", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b123.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b123", + "slambda1" + ], + "range": { + "start": 12960, + "end": 13010 + } + }, + { + "id": "effect_148", + "effect_id": "effect@13035:13092", + "bound_var": "b125", + "source_text": "ctx.insert_t51_lower(b124.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b124" + ], + "range": { + "start": 13035, + "end": 13092 + } + }, + { + "id": "effect_149", + "effect_id": "effect@13117:13165", + "bound_var": "r126", + "source_text": "ctx.insert_t51_approx(b32.clone(), b125.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b125", + "b32" + ], + "range": { + "start": 13117, + "end": 13165 + } + }, + { + "id": "effect_150", + "effect_id": "effect@13179:13216", + "bound_var": null, + "source_text": "ctx.set_to_extract(132, r126.clone())", + "semantic_text": "to_extract(132) = r126", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r126" + ], + "range": { + "start": 13179, + "end": 13216 + } + }, + { + "id": "effect_151", + "effect_id": "effect@13241:13281", + "bound_var": "b127", + "source_text": "ctx.insert_t51_num(\"-1/5040\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 13241, + "end": 13281 + } + }, + { + "id": "effect_152", + "effect_id": "effect@13306:13351", + "bound_var": "b128", + "source_text": "ctx.insert_t51_mul(b127.clone(), b91.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b127", + "b91" + ], + "range": { + "start": 13306, + "end": 13351 + } + }, + { + "id": "effect_153", + "effect_id": "effect@13376:13422", + "bound_var": "b129", + "source_text": "ctx.insert_t51_add(b119.clone(), b128.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b119", + "b128" + ], + "range": { + "start": 13376, + "end": 13422 + } + }, + { + "id": "effect_154", + "effect_id": "effect@13447:13492", + "bound_var": "b130", + "source_text": "ctx.insert_t51_mul(b91.clone(), b129.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b129", + "b91" + ], + "range": { + "start": 13447, + "end": 13492 + } + }, + { + "id": "effect_155", + "effect_id": "effect@13517:13562", + "bound_var": "b131", + "source_text": "ctx.insert_t51_sub(b130.clone(), b74.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b130", + "b74" + ], + "range": { + "start": 13517, + "end": 13562 + } + }, + { + "id": "effect_156", + "effect_id": "effect@13587:13632", + "bound_var": "b132", + "source_text": "ctx.insert_t51_mul(b91.clone(), b131.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b131", + "b91" + ], + "range": { + "start": 13587, + "end": 13632 + } + }, + { + "id": "effect_157", + "effect_id": "effect@13657:13702", + "bound_var": "b133", + "source_text": "ctx.insert_t51_add(b87.clone(), b132.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b132", + "b87" + ], + "range": { + "start": 13657, + "end": 13702 + } + }, + { + "id": "effect_158", + "effect_id": "effect@13727:13777", + "bound_var": "b134", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b133.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b133", + "slambda1" + ], + "range": { + "start": 13727, + "end": 13777 + } + }, + { + "id": "effect_159", + "effect_id": "effect@13802:13859", + "bound_var": "b135", + "source_text": "ctx.insert_t51_lower(b134.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b134" + ], + "range": { + "start": 13802, + "end": 13859 + } + }, + { + "id": "effect_160", + "effect_id": "effect@13884:13932", + "bound_var": "r136", + "source_text": "ctx.insert_t51_approx(b32.clone(), b135.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b135", + "b32" + ], + "range": { + "start": 13884, + "end": 13932 + } + }, + { + "id": "effect_161", + "effect_id": "effect@13946:13983", + "bound_var": null, + "source_text": "ctx.set_to_extract(142, r136.clone())", + "semantic_text": "to_extract(142) = r136", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r136" + ], + "range": { + "start": 13946, + "end": 13983 + } + }, + { + "id": "effect_162", + "effect_id": "effect@14008:14057", + "bound_var": "b137", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b33.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b33", + "slambda1" + ], + "range": { + "start": 14008, + "end": 14057 + } + }, + { + "id": "effect_163", + "effect_id": "effect@14082:14139", + "bound_var": "b138", + "source_text": "ctx.insert_t51_lower(b137.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b137" + ], + "range": { + "start": 14082, + "end": 14139 + } + }, + { + "id": "effect_164", + "effect_id": "effect@14164:14212", + "bound_var": "r139", + "source_text": "ctx.insert_t51_approx(b34.clone(), b138.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b138", + "b34" + ], + "range": { + "start": 14164, + "end": 14212 + } + }, + { + "id": "effect_165", + "effect_id": "effect@14226:14263", + "bound_var": null, + "source_text": "ctx.set_to_extract(145, r139.clone())", + "semantic_text": "to_extract(145) = r139", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r139" + ], + "range": { + "start": 14226, + "end": 14263 + } + }, + { + "id": "effect_166", + "effect_id": "effect@14288:14332", + "bound_var": "b140", + "source_text": "ctx.insert_t51_mul(b91.clone(), b33.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b33", + "b91" + ], + "range": { + "start": 14288, + "end": 14332 + } + }, + { + "id": "effect_167", + "effect_id": "effect@14357:14403", + "bound_var": "b141", + "source_text": "ctx.insert_t51_mul(b113.clone(), b140.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b140" + ], + "range": { + "start": 14357, + "end": 14403 + } + }, + { + "id": "effect_168", + "effect_id": "effect@14428:14473", + "bound_var": "b142", + "source_text": "ctx.insert_t51_add(b33.clone(), b141.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b141", + "b33" + ], + "range": { + "start": 14428, + "end": 14473 + } + }, + { + "id": "effect_169", + "effect_id": "effect@14498:14548", + "bound_var": "b143", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b142.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b142", + "slambda1" + ], + "range": { + "start": 14498, + "end": 14548 + } + }, + { + "id": "effect_170", + "effect_id": "effect@14573:14630", + "bound_var": "b144", + "source_text": "ctx.insert_t51_lower(b143.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b143" + ], + "range": { + "start": 14573, + "end": 14630 + } + }, + { + "id": "effect_171", + "effect_id": "effect@14655:14703", + "bound_var": "r145", + "source_text": "ctx.insert_t51_approx(b34.clone(), b144.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b144", + "b34" + ], + "range": { + "start": 14655, + "end": 14703 + } + }, + { + "id": "effect_172", + "effect_id": "effect@14717:14754", + "bound_var": null, + "source_text": "ctx.set_to_extract(151, r145.clone())", + "semantic_text": "to_extract(151) = r145", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r145" + ], + "range": { + "start": 14717, + "end": 14754 + } + }, + { + "id": "effect_173", + "effect_id": "effect@14779:14824", + "bound_var": "b146", + "source_text": "ctx.insert_t51_mul(b113.clone(), b33.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b33" + ], + "range": { + "start": 14779, + "end": 14824 + } + }, + { + "id": "effect_174", + "effect_id": "effect@14849:14895", + "bound_var": "b147", + "source_text": "ctx.insert_t51_mul(b119.clone(), b140.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b119", + "b140" + ], + "range": { + "start": 14849, + "end": 14895 + } + }, + { + "id": "effect_175", + "effect_id": "effect@14920:14966", + "bound_var": "b148", + "source_text": "ctx.insert_t51_add(b146.clone(), b147.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b146", + "b147" + ], + "range": { + "start": 14920, + "end": 14966 + } + }, + { + "id": "effect_176", + "effect_id": "effect@14991:15036", + "bound_var": "b149", + "source_text": "ctx.insert_t51_mul(b91.clone(), b148.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b148", + "b91" + ], + "range": { + "start": 14991, + "end": 15036 + } + }, + { + "id": "effect_177", + "effect_id": "effect@15061:15106", + "bound_var": "b150", + "source_text": "ctx.insert_t51_add(b33.clone(), b149.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b149", + "b33" + ], + "range": { + "start": 15061, + "end": 15106 + } + }, + { + "id": "effect_178", + "effect_id": "effect@15131:15181", + "bound_var": "b151", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b150.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b150", + "slambda1" + ], + "range": { + "start": 15131, + "end": 15181 + } + }, + { + "id": "effect_179", + "effect_id": "effect@15206:15263", + "bound_var": "b152", + "source_text": "ctx.insert_t51_lower(b151.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b151" + ], + "range": { + "start": 15206, + "end": 15263 + } + }, + { + "id": "effect_180", + "effect_id": "effect@15288:15336", + "bound_var": "r153", + "source_text": "ctx.insert_t51_approx(b34.clone(), b152.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b152", + "b34" + ], + "range": { + "start": 15288, + "end": 15336 + } + }, + { + "id": "effect_181", + "effect_id": "effect@15350:15387", + "bound_var": null, + "source_text": "ctx.set_to_extract(159, r153.clone())", + "semantic_text": "to_extract(159) = r153", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r153" + ], + "range": { + "start": 15350, + "end": 15387 + } + }, + { + "id": "effect_182", + "effect_id": "effect@15412:15458", + "bound_var": "b154", + "source_text": "ctx.insert_t51_mul(b127.clone(), b140.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b127", + "b140" + ], + "range": { + "start": 15412, + "end": 15458 + } + }, + { + "id": "effect_183", + "effect_id": "effect@15483:15528", + "bound_var": "b155", + "source_text": "ctx.insert_t51_mul(b119.clone(), b33.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b119", + "b33" + ], + "range": { + "start": 15483, + "end": 15528 + } + }, + { + "id": "effect_184", + "effect_id": "effect@15553:15599", + "bound_var": "b156", + "source_text": "ctx.insert_t51_add(b154.clone(), b155.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b154", + "b155" + ], + "range": { + "start": 15553, + "end": 15599 + } + }, + { + "id": "effect_185", + "effect_id": "effect@15624:15669", + "bound_var": "b157", + "source_text": "ctx.insert_t51_mul(b91.clone(), b156.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b156", + "b91" + ], + "range": { + "start": 15624, + "end": 15669 + } + }, + { + "id": "effect_186", + "effect_id": "effect@15694:15740", + "bound_var": "b158", + "source_text": "ctx.insert_t51_add(b146.clone(), b157.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b146", + "b157" + ], + "range": { + "start": 15694, + "end": 15740 + } + }, + { + "id": "effect_187", + "effect_id": "effect@15765:15810", + "bound_var": "b159", + "source_text": "ctx.insert_t51_mul(b91.clone(), b158.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b158", + "b91" + ], + "range": { + "start": 15765, + "end": 15810 + } + }, + { + "id": "effect_188", + "effect_id": "effect@15835:15880", + "bound_var": "b160", + "source_text": "ctx.insert_t51_add(b33.clone(), b159.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b159", + "b33" + ], + "range": { + "start": 15835, + "end": 15880 + } + }, + { + "id": "effect_189", + "effect_id": "effect@15905:15955", + "bound_var": "b161", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b160.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b160", + "slambda1" + ], + "range": { + "start": 15905, + "end": 15955 + } + }, + { + "id": "effect_190", + "effect_id": "effect@15980:16037", + "bound_var": "b162", + "source_text": "ctx.insert_t51_lower(b161.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b161" + ], + "range": { + "start": 15980, + "end": 16037 + } + }, + { + "id": "effect_191", + "effect_id": "effect@16062:16110", + "bound_var": "r163", + "source_text": "ctx.insert_t51_approx(b34.clone(), b162.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b162", + "b34" + ], + "range": { + "start": 16062, + "end": 16110 + } + }, + { + "id": "effect_192", + "effect_id": "effect@16124:16161", + "bound_var": null, + "source_text": "ctx.set_to_extract(169, r163.clone())", + "semantic_text": "to_extract(169) = r163", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r163" + ], + "range": { + "start": 16124, + "end": 16161 + } + }, + { + "id": "effect_193", + "effect_id": "effect@16186:16242", + "bound_var": "b164", + "source_text": "ctx.insert_t51_lower(b30.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b30" + ], + "range": { + "start": 16186, + "end": 16242 + } + }, + { + "id": "effect_194", + "effect_id": "effect@16267:16315", + "bound_var": "r165", + "source_text": "ctx.insert_t51_approx(b35.clone(), b164.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b164", + "b35" + ], + "range": { + "start": 16267, + "end": 16315 + } + }, + { + "id": "effect_195", + "effect_id": "effect@16329:16366", + "bound_var": null, + "source_text": "ctx.set_to_extract(171, r165.clone())", + "semantic_text": "to_extract(171) = r165", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r165" + ], + "range": { + "start": 16329, + "end": 16366 + } + }, + { + "id": "effect_196", + "effect_id": "effect@16391:16436", + "bound_var": "b166", + "source_text": "ctx.insert_t51_add(b30.clone(), b137.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b137", + "b30" + ], + "range": { + "start": 16391, + "end": 16436 + } + }, + { + "id": "effect_197", + "effect_id": "effect@16461:16518", + "bound_var": "b167", + "source_text": "ctx.insert_t51_lower(b166.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b166" + ], + "range": { + "start": 16461, + "end": 16518 + } + }, + { + "id": "effect_198", + "effect_id": "effect@16543:16591", + "bound_var": "r168", + "source_text": "ctx.insert_t51_approx(b35.clone(), b167.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b167", + "b35" + ], + "range": { + "start": 16543, + "end": 16591 + } + }, + { + "id": "effect_199", + "effect_id": "effect@16605:16642", + "bound_var": null, + "source_text": "ctx.set_to_extract(174, r168.clone())", + "semantic_text": "to_extract(174) = r168", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r168" + ], + "range": { + "start": 16605, + "end": 16642 + } + }, + { + "id": "effect_200", + "effect_id": "effect@16667:16716", + "bound_var": "b169", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b30.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b30", + "slambda1" + ], + "range": { + "start": 16667, + "end": 16716 + } + }, + { + "id": "effect_201", + "effect_id": "effect@16741:16786", + "bound_var": "b170", + "source_text": "ctx.insert_t51_mul(b65.clone(), b169.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b169", + "b65" + ], + "range": { + "start": 16741, + "end": 16786 + } + }, + { + "id": "effect_202", + "effect_id": "effect@16811:16856", + "bound_var": "b171", + "source_text": "ctx.insert_t51_add(b33.clone(), b170.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b170", + "b33" + ], + "range": { + "start": 16811, + "end": 16856 + } + }, + { + "id": "effect_203", + "effect_id": "effect@16881:16931", + "bound_var": "b172", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b171.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b171", + "slambda1" + ], + "range": { + "start": 16881, + "end": 16931 + } + }, + { + "id": "effect_204", + "effect_id": "effect@16956:17001", + "bound_var": "b173", + "source_text": "ctx.insert_t51_add(b30.clone(), b172.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b172", + "b30" + ], + "range": { + "start": 16956, + "end": 17001 + } + }, + { + "id": "effect_205", + "effect_id": "effect@17026:17083", + "bound_var": "b174", + "source_text": "ctx.insert_t51_lower(b173.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b173" + ], + "range": { + "start": 17026, + "end": 17083 + } + }, + { + "id": "effect_206", + "effect_id": "effect@17108:17156", + "bound_var": "r175", + "source_text": "ctx.insert_t51_approx(b35.clone(), b174.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b174", + "b35" + ], + "range": { + "start": 17108, + "end": 17156 + } + }, + { + "id": "effect_207", + "effect_id": "effect@17170:17207", + "bound_var": null, + "source_text": "ctx.set_to_extract(181, r175.clone())", + "semantic_text": "to_extract(181) = r175", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r175" + ], + "range": { + "start": 17170, + "end": 17207 + } + }, + { + "id": "effect_208", + "effect_id": "effect@17232:17276", + "bound_var": "b176", + "source_text": "ctx.insert_t51_mul(b65.clone(), b30.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b30", + "b65" + ], + "range": { + "start": 17232, + "end": 17276 + } + }, + { + "id": "effect_209", + "effect_id": "effect@17301:17347", + "bound_var": "b177", + "source_text": "ctx.insert_t51_mul(b113.clone(), b137.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b137" + ], + "range": { + "start": 17301, + "end": 17347 + } + }, + { + "id": "effect_210", + "effect_id": "effect@17372:17418", + "bound_var": "b178", + "source_text": "ctx.insert_t51_add(b176.clone(), b177.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b176", + "b177" + ], + "range": { + "start": 17372, + "end": 17418 + } + }, + { + "id": "effect_211", + "effect_id": "effect@17443:17493", + "bound_var": "b179", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b178.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b178", + "slambda1" + ], + "range": { + "start": 17443, + "end": 17493 + } + }, + { + "id": "effect_212", + "effect_id": "effect@17518:17563", + "bound_var": "b180", + "source_text": "ctx.insert_t51_add(b33.clone(), b179.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b179", + "b33" + ], + "range": { + "start": 17518, + "end": 17563 + } + }, + { + "id": "effect_213", + "effect_id": "effect@17588:17638", + "bound_var": "b181", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b180.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b180", + "slambda1" + ], + "range": { + "start": 17588, + "end": 17638 + } + }, + { + "id": "effect_214", + "effect_id": "effect@17663:17708", + "bound_var": "b182", + "source_text": "ctx.insert_t51_add(b30.clone(), b181.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b181", + "b30" + ], + "range": { + "start": 17663, + "end": 17708 + } + }, + { + "id": "effect_215", + "effect_id": "effect@17733:17790", + "bound_var": "b183", + "source_text": "ctx.insert_t51_lower(b182.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b182" + ], + "range": { + "start": 17733, + "end": 17790 + } + }, + { + "id": "effect_216", + "effect_id": "effect@17815:17863", + "bound_var": "r184", + "source_text": "ctx.insert_t51_approx(b35.clone(), b183.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b183", + "b35" + ], + "range": { + "start": 17815, + "end": 17863 + } + }, + { + "id": "effect_217", + "effect_id": "effect@17877:17914", + "bound_var": null, + "source_text": "ctx.set_to_extract(190, r184.clone())", + "semantic_text": "to_extract(190) = r184", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r184" + ], + "range": { + "start": 17877, + "end": 17914 + } + }, + { + "id": "effect_218", + "effect_id": "effect@17939:17983", + "bound_var": "b185", + "source_text": "ctx.insert_t51_mul(b12.clone(), b56.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b12", + "b56" + ], + "range": { + "start": 17939, + "end": 17983 + } + }, + { + "id": "effect_219", + "effect_id": "effect@18008:18053", + "bound_var": "b186", + "source_text": "ctx.insert_t51_mul(b11.clone(), b185.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b11", + "b185" + ], + "range": { + "start": 18008, + "end": 18053 + } + }, + { + "id": "effect_220", + "effect_id": "effect@18078:18135", + "bound_var": "b187", + "source_text": "ctx.insert_t51_lower(b186.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b186" + ], + "range": { + "start": 18078, + "end": 18135 + } + }, + { + "id": "effect_221", + "effect_id": "effect@18160:18208", + "bound_var": "r188", + "source_text": "ctx.insert_t51_approx(b18.clone(), b187.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b18", + "b187" + ], + "range": { + "start": 18160, + "end": 18208 + } + }, + { + "id": "effect_222", + "effect_id": "effect@18222:18259", + "bound_var": null, + "source_text": "ctx.set_to_extract(194, r188.clone())", + "semantic_text": "to_extract(194) = r188", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r188" + ], + "range": { + "start": 18222, + "end": 18259 + } + }, + { + "id": "effect_223", + "effect_id": "effect@18284:18328", + "bound_var": "b189", + "source_text": "ctx.insert_t51_mul(b12.clone(), b59.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b12", + "b59" + ], + "range": { + "start": 18284, + "end": 18328 + } + }, + { + "id": "effect_224", + "effect_id": "effect@18353:18398", + "bound_var": "b190", + "source_text": "ctx.insert_t51_mul(b11.clone(), b189.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b11", + "b189" + ], + "range": { + "start": 18353, + "end": 18398 + } + }, + { + "id": "effect_225", + "effect_id": "effect@18423:18473", + "bound_var": "b191", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b190.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b190", + "slambda1" + ], + "range": { + "start": 18423, + "end": 18473 + } + }, + { + "id": "effect_226", + "effect_id": "effect@18498:18543", + "bound_var": "b192", + "source_text": "ctx.insert_t51_mul(b49.clone(), b191.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b191", + "b49" + ], + "range": { + "start": 18498, + "end": 18543 + } + }, + { + "id": "effect_227", + "effect_id": "effect@18568:18614", + "bound_var": "b193", + "source_text": "ctx.insert_t51_add(b192.clone(), b186.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b186", + "b192" + ], + "range": { + "start": 18568, + "end": 18614 + } + }, + { + "id": "effect_228", + "effect_id": "effect@18639:18696", + "bound_var": "b194", + "source_text": "ctx.insert_t51_lower(b193.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b193" + ], + "range": { + "start": 18639, + "end": 18696 + } + }, + { + "id": "effect_229", + "effect_id": "effect@18721:18769", + "bound_var": "r195", + "source_text": "ctx.insert_t51_approx(b18.clone(), b194.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b18", + "b194" + ], + "range": { + "start": 18721, + "end": 18769 + } + }, + { + "id": "effect_230", + "effect_id": "effect@18783:18820", + "bound_var": null, + "source_text": "ctx.set_to_extract(201, r195.clone())", + "semantic_text": "to_extract(201) = r195", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r195" + ], + "range": { + "start": 18783, + "end": 18820 + } + }, + { + "id": "effect_231", + "effect_id": "effect@18845:18890", + "bound_var": "b196", + "source_text": "ctx.insert_t51_mul(b49.clone(), b190.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b190", + "b49" + ], + "range": { + "start": 18845, + "end": 18890 + } + }, + { + "id": "effect_232", + "effect_id": "effect@18915:18965", + "bound_var": "b197", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b186.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b186", + "slambda1" + ], + "range": { + "start": 18915, + "end": 18965 + } + }, + { + "id": "effect_233", + "effect_id": "effect@18990:19035", + "bound_var": "b198", + "source_text": "ctx.insert_t51_mul(b65.clone(), b197.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b197", + "b65" + ], + "range": { + "start": 18990, + "end": 19035 + } + }, + { + "id": "effect_234", + "effect_id": "effect@19060:19106", + "bound_var": "b199", + "source_text": "ctx.insert_t51_add(b196.clone(), b198.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b196", + "b198" + ], + "range": { + "start": 19060, + "end": 19106 + } + }, + { + "id": "effect_235", + "effect_id": "effect@19131:19181", + "bound_var": "b200", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b199.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b199", + "slambda1" + ], + "range": { + "start": 19131, + "end": 19181 + } + }, + { + "id": "effect_236", + "effect_id": "effect@19206:19252", + "bound_var": "b201", + "source_text": "ctx.insert_t51_add(b200.clone(), b186.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b186", + "b200" + ], + "range": { + "start": 19206, + "end": 19252 + } + }, + { + "id": "effect_237", + "effect_id": "effect@19277:19334", + "bound_var": "b202", + "source_text": "ctx.insert_t51_lower(b201.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b201" + ], + "range": { + "start": 19277, + "end": 19334 + } + }, + { + "id": "effect_238", + "effect_id": "effect@19359:19407", + "bound_var": "r203", + "source_text": "ctx.insert_t51_approx(b18.clone(), b202.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b18", + "b202" + ], + "range": { + "start": 19359, + "end": 19407 + } + }, + { + "id": "effect_239", + "effect_id": "effect@19421:19458", + "bound_var": null, + "source_text": "ctx.set_to_extract(209, r203.clone())", + "semantic_text": "to_extract(209) = r203", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r203" + ], + "range": { + "start": 19421, + "end": 19458 + } + }, + { + "id": "effect_240", + "effect_id": "effect@19483:19528", + "bound_var": "b204", + "source_text": "ctx.insert_t51_mul(b65.clone(), b186.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b186", + "b65" + ], + "range": { + "start": 19483, + "end": 19528 + } + }, + { + "id": "effect_241", + "effect_id": "effect@19553:19598", + "bound_var": "b205", + "source_text": "ctx.insert_t51_mul(b74.clone(), b191.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b191", + "b74" + ], + "range": { + "start": 19553, + "end": 19598 + } + }, + { + "id": "effect_242", + "effect_id": "effect@19623:19669", + "bound_var": "b206", + "source_text": "ctx.insert_t51_add(b204.clone(), b205.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b204", + "b205" + ], + "range": { + "start": 19623, + "end": 19669 + } + }, + { + "id": "effect_243", + "effect_id": "effect@19694:19744", + "bound_var": "b207", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b206.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b206", + "slambda1" + ], + "range": { + "start": 19694, + "end": 19744 + } + }, + { + "id": "effect_244", + "effect_id": "effect@19769:19815", + "bound_var": "b208", + "source_text": "ctx.insert_t51_add(b196.clone(), b207.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b196", + "b207" + ], + "range": { + "start": 19769, + "end": 19815 + } + }, + { + "id": "effect_245", + "effect_id": "effect@19840:19890", + "bound_var": "b209", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b208.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b208", + "slambda1" + ], + "range": { + "start": 19840, + "end": 19890 + } + }, + { + "id": "effect_246", + "effect_id": "effect@19915:19961", + "bound_var": "b210", + "source_text": "ctx.insert_t51_add(b209.clone(), b186.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b186", + "b209" + ], + "range": { + "start": 19915, + "end": 19961 + } + }, + { + "id": "effect_247", + "effect_id": "effect@19986:20043", + "bound_var": "b211", + "source_text": "ctx.insert_t51_lower(b210.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b210" + ], + "range": { + "start": 19986, + "end": 20043 + } + }, + { + "id": "effect_248", + "effect_id": "effect@20068:20116", + "bound_var": "r212", + "source_text": "ctx.insert_t51_approx(b18.clone(), b211.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b18", + "b211" + ], + "range": { + "start": 20068, + "end": 20116 + } + }, + { + "id": "effect_249", + "effect_id": "effect@20130:20167", + "bound_var": null, + "source_text": "ctx.set_to_extract(218, r212.clone())", + "semantic_text": "to_extract(218) = r212", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r212" + ], + "range": { + "start": 20130, + "end": 20167 + } + }, + { + "id": "effect_250", + "effect_id": "effect@20192:20236", + "bound_var": "b213", + "source_text": "ctx.insert_t51_mul(b30.clone(), b12.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b12", + "b30" + ], + "range": { + "start": 20192, + "end": 20236 + } + }, + { + "id": "effect_251", + "effect_id": "effect@20261:20318", + "bound_var": "b214", + "source_text": "ctx.insert_t51_lower(b213.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b213" + ], + "range": { + "start": 20261, + "end": 20318 + } + }, + { + "id": "effect_252", + "effect_id": "effect@20343:20391", + "bound_var": "r215", + "source_text": "ctx.insert_t51_approx(b40.clone(), b214.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b214", + "b40" + ], + "range": { + "start": 20343, + "end": 20391 + } + }, + { + "id": "effect_253", + "effect_id": "effect@20405:20442", + "bound_var": null, + "source_text": "ctx.set_to_extract(221, r215.clone())", + "semantic_text": "to_extract(221) = r215", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r215" + ], + "range": { + "start": 20405, + "end": 20442 + } + }, + { + "id": "effect_254", + "effect_id": "effect@20467:20511", + "bound_var": "b216", + "source_text": "ctx.insert_t51_mul(b12.clone(), b33.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b12", + "b33" + ], + "range": { + "start": 20467, + "end": 20511 + } + }, + { + "id": "effect_255", + "effect_id": "effect@20536:20586", + "bound_var": "b217", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b216.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b216", + "slambda1" + ], + "range": { + "start": 20536, + "end": 20586 + } + }, + { + "id": "effect_256", + "effect_id": "effect@20611:20657", + "bound_var": "b218", + "source_text": "ctx.insert_t51_add(b217.clone(), b213.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b213", + "b217" + ], + "range": { + "start": 20611, + "end": 20657 + } + }, + { + "id": "effect_257", + "effect_id": "effect@20682:20739", + "bound_var": "b219", + "source_text": "ctx.insert_t51_lower(b218.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b218" + ], + "range": { + "start": 20682, + "end": 20739 + } + }, + { + "id": "effect_258", + "effect_id": "effect@20764:20812", + "bound_var": "r220", + "source_text": "ctx.insert_t51_approx(b40.clone(), b219.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b219", + "b40" + ], + "range": { + "start": 20764, + "end": 20812 + } + }, + { + "id": "effect_259", + "effect_id": "effect@20826:20863", + "bound_var": null, + "source_text": "ctx.set_to_extract(226, r220.clone())", + "semantic_text": "to_extract(226) = r220", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r220" + ], + "range": { + "start": 20826, + "end": 20863 + } + }, + { + "id": "effect_260", + "effect_id": "effect@20888:20938", + "bound_var": "b221", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b213.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b213", + "slambda1" + ], + "range": { + "start": 20888, + "end": 20938 + } + }, + { + "id": "effect_261", + "effect_id": "effect@20963:21008", + "bound_var": "b222", + "source_text": "ctx.insert_t51_mul(b65.clone(), b221.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b221", + "b65" + ], + "range": { + "start": 20963, + "end": 21008 + } + }, + { + "id": "effect_262", + "effect_id": "effect@21033:21079", + "bound_var": "b223", + "source_text": "ctx.insert_t51_add(b222.clone(), b216.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b216", + "b222" + ], + "range": { + "start": 21033, + "end": 21079 + } + }, + { + "id": "effect_263", + "effect_id": "effect@21104:21154", + "bound_var": "b224", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b223.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b223", + "slambda1" + ], + "range": { + "start": 21104, + "end": 21154 + } + }, + { + "id": "effect_264", + "effect_id": "effect@21179:21225", + "bound_var": "b225", + "source_text": "ctx.insert_t51_add(b224.clone(), b213.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b213", + "b224" + ], + "range": { + "start": 21179, + "end": 21225 + } + }, + { + "id": "effect_265", + "effect_id": "effect@21250:21307", + "bound_var": "b226", + "source_text": "ctx.insert_t51_lower(b225.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b225" + ], + "range": { + "start": 21250, + "end": 21307 + } + }, + { + "id": "effect_266", + "effect_id": "effect@21332:21380", + "bound_var": "r227", + "source_text": "ctx.insert_t51_approx(b40.clone(), b226.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b226", + "b40" + ], + "range": { + "start": 21332, + "end": 21380 + } + }, + { + "id": "effect_267", + "effect_id": "effect@21394:21431", + "bound_var": null, + "source_text": "ctx.set_to_extract(233, r227.clone())", + "semantic_text": "to_extract(233) = r227", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r227" + ], + "range": { + "start": 21394, + "end": 21431 + } + }, + { + "id": "effect_268", + "effect_id": "effect@21456:21501", + "bound_var": "b228", + "source_text": "ctx.insert_t51_mul(b65.clone(), b213.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b213", + "b65" + ], + "range": { + "start": 21456, + "end": 21501 + } + }, + { + "id": "effect_269", + "effect_id": "effect@21526:21572", + "bound_var": "b229", + "source_text": "ctx.insert_t51_mul(b113.clone(), b217.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b217" + ], + "range": { + "start": 21526, + "end": 21572 + } + }, + { + "id": "effect_270", + "effect_id": "effect@21597:21643", + "bound_var": "b230", + "source_text": "ctx.insert_t51_add(b228.clone(), b229.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b228", + "b229" + ], + "range": { + "start": 21597, + "end": 21643 + } + }, + { + "id": "effect_271", + "effect_id": "effect@21668:21718", + "bound_var": "b231", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b230.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b230", + "slambda1" + ], + "range": { + "start": 21668, + "end": 21718 + } + }, + { + "id": "effect_272", + "effect_id": "effect@21743:21789", + "bound_var": "b232", + "source_text": "ctx.insert_t51_add(b231.clone(), b216.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b216", + "b231" + ], + "range": { + "start": 21743, + "end": 21789 + } + }, + { + "id": "effect_273", + "effect_id": "effect@21814:21864", + "bound_var": "b233", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b232.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b232", + "slambda1" + ], + "range": { + "start": 21814, + "end": 21864 + } + }, + { + "id": "effect_274", + "effect_id": "effect@21889:21935", + "bound_var": "b234", + "source_text": "ctx.insert_t51_add(b233.clone(), b213.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b213", + "b233" + ], + "range": { + "start": 21889, + "end": 21935 + } + }, + { + "id": "effect_275", + "effect_id": "effect@21960:22017", + "bound_var": "b235", + "source_text": "ctx.insert_t51_lower(b234.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b234" + ], + "range": { + "start": 21960, + "end": 22017 + } + }, + { + "id": "effect_276", + "effect_id": "effect@22042:22090", + "bound_var": "r236", + "source_text": "ctx.insert_t51_approx(b40.clone(), b235.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b235", + "b40" + ], + "range": { + "start": 22042, + "end": 22090 + } + }, + { + "id": "effect_277", + "effect_id": "effect@22104:22141", + "bound_var": null, + "source_text": "ctx.set_to_extract(242, r236.clone())", + "semantic_text": "to_extract(242) = r236", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r236" + ], + "range": { + "start": 22104, + "end": 22141 + } + }, + { + "id": "effect_278", + "effect_id": "effect@22166:22210", + "bound_var": "b237", + "source_text": "ctx.insert_t51_mul(b30.clone(), b13.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b13", + "b30" + ], + "range": { + "start": 22166, + "end": 22210 + } + }, + { + "id": "effect_279", + "effect_id": "effect@22235:22280", + "bound_var": "b238", + "source_text": "ctx.insert_t51_add(b237.clone(), b10.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b10", + "b237" + ], + "range": { + "start": 22235, + "end": 22280 + } + }, + { + "id": "effect_280", + "effect_id": "effect@22305:22362", + "bound_var": "b239", + "source_text": "ctx.insert_t51_lower(b238.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b238" + ], + "range": { + "start": 22305, + "end": 22362 + } + }, + { + "id": "effect_281", + "effect_id": "effect@22387:22435", + "bound_var": "r240", + "source_text": "ctx.insert_t51_approx(b42.clone(), b239.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b239", + "b42" + ], + "range": { + "start": 22387, + "end": 22435 + } + }, + { + "id": "effect_282", + "effect_id": "effect@22449:22486", + "bound_var": null, + "source_text": "ctx.set_to_extract(246, r240.clone())", + "semantic_text": "to_extract(246) = r240", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r240" + ], + "range": { + "start": 22449, + "end": 22486 + } + }, + { + "id": "effect_283", + "effect_id": "effect@22511:22556", + "bound_var": "b241", + "source_text": "ctx.insert_t51_mul(b11.clone(), b216.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b11", + "b216" + ], + "range": { + "start": 22511, + "end": 22556 + } + }, + { + "id": "effect_284", + "effect_id": "effect@22581:22631", + "bound_var": "b242", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b241.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b241", + "slambda1" + ], + "range": { + "start": 22581, + "end": 22631 + } + }, + { + "id": "effect_285", + "effect_id": "effect@22656:22702", + "bound_var": "b243", + "source_text": "ctx.insert_t51_add(b242.clone(), b238.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b238", + "b242" + ], + "range": { + "start": 22656, + "end": 22702 + } + }, + { + "id": "effect_286", + "effect_id": "effect@22727:22784", + "bound_var": "b244", + "source_text": "ctx.insert_t51_lower(b243.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b243" + ], + "range": { + "start": 22727, + "end": 22784 + } + }, + { + "id": "effect_287", + "effect_id": "effect@22809:22857", + "bound_var": "r245", + "source_text": "ctx.insert_t51_approx(b42.clone(), b244.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b244", + "b42" + ], + "range": { + "start": 22809, + "end": 22857 + } + }, + { + "id": "effect_288", + "effect_id": "effect@22871:22908", + "bound_var": null, + "source_text": "ctx.set_to_extract(251, r245.clone())", + "semantic_text": "to_extract(251) = r245", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r245" + ], + "range": { + "start": 22871, + "end": 22908 + } + }, + { + "id": "effect_289", + "effect_id": "effect@22933:22983", + "bound_var": "b246", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b237.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b237", + "slambda1" + ], + "range": { + "start": 22933, + "end": 22983 + } + }, + { + "id": "effect_290", + "effect_id": "effect@23008:23053", + "bound_var": "b247", + "source_text": "ctx.insert_t51_mul(b65.clone(), b246.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b246", + "b65" + ], + "range": { + "start": 23008, + "end": 23053 + } + }, + { + "id": "effect_291", + "effect_id": "effect@23078:23124", + "bound_var": "b248", + "source_text": "ctx.insert_t51_add(b247.clone(), b241.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b241", + "b247" + ], + "range": { + "start": 23078, + "end": 23124 + } + }, + { + "id": "effect_292", + "effect_id": "effect@23149:23199", + "bound_var": "b249", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b248.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b248", + "slambda1" + ], + "range": { + "start": 23149, + "end": 23199 + } + }, + { + "id": "effect_293", + "effect_id": "effect@23224:23270", + "bound_var": "b250", + "source_text": "ctx.insert_t51_add(b249.clone(), b238.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b238", + "b249" + ], + "range": { + "start": 23224, + "end": 23270 + } + }, + { + "id": "effect_294", + "effect_id": "effect@23295:23352", + "bound_var": "b251", + "source_text": "ctx.insert_t51_lower(b250.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b250" + ], + "range": { + "start": 23295, + "end": 23352 + } + }, + { + "id": "effect_295", + "effect_id": "effect@23377:23425", + "bound_var": "r252", + "source_text": "ctx.insert_t51_approx(b42.clone(), b251.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b251", + "b42" + ], + "range": { + "start": 23377, + "end": 23425 + } + }, + { + "id": "effect_296", + "effect_id": "effect@23439:23476", + "bound_var": null, + "source_text": "ctx.set_to_extract(258, r252.clone())", + "semantic_text": "to_extract(258) = r252", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r252" + ], + "range": { + "start": 23439, + "end": 23476 + } + }, + { + "id": "effect_297", + "effect_id": "effect@23501:23546", + "bound_var": "b253", + "source_text": "ctx.insert_t51_mul(b65.clone(), b237.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b237", + "b65" + ], + "range": { + "start": 23501, + "end": 23546 + } + }, + { + "id": "effect_298", + "effect_id": "effect@23571:23617", + "bound_var": "b254", + "source_text": "ctx.insert_t51_mul(b113.clone(), b242.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b242" + ], + "range": { + "start": 23571, + "end": 23617 + } + }, + { + "id": "effect_299", + "effect_id": "effect@23642:23688", + "bound_var": "b255", + "source_text": "ctx.insert_t51_add(b253.clone(), b254.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b253", + "b254" + ], + "range": { + "start": 23642, + "end": 23688 + } + }, + { + "id": "effect_300", + "effect_id": "effect@23713:23763", + "bound_var": "b256", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b255.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b255", + "slambda1" + ], + "range": { + "start": 23713, + "end": 23763 + } + }, + { + "id": "effect_301", + "effect_id": "effect@23788:23834", + "bound_var": "b257", + "source_text": "ctx.insert_t51_add(b256.clone(), b241.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b241", + "b256" + ], + "range": { + "start": 23788, + "end": 23834 + } + }, + { + "id": "effect_302", + "effect_id": "effect@23859:23909", + "bound_var": "b258", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b257.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b257", + "slambda1" + ], + "range": { + "start": 23859, + "end": 23909 + } + }, + { + "id": "effect_303", + "effect_id": "effect@23934:23980", + "bound_var": "b259", + "source_text": "ctx.insert_t51_add(b258.clone(), b238.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b238", + "b258" + ], + "range": { + "start": 23934, + "end": 23980 + } + }, + { + "id": "effect_304", + "effect_id": "effect@24005:24062", + "bound_var": "b260", + "source_text": "ctx.insert_t51_lower(b259.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b259" + ], + "range": { + "start": 24005, + "end": 24062 + } + }, + { + "id": "effect_305", + "effect_id": "effect@24087:24135", + "bound_var": "r261", + "source_text": "ctx.insert_t51_approx(b42.clone(), b260.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b260", + "b42" + ], + "range": { + "start": 24087, + "end": 24135 + } + }, + { + "id": "effect_306", + "effect_id": "effect@24149:24186", + "bound_var": null, + "source_text": "ctx.set_to_extract(267, r261.clone())", + "semantic_text": "to_extract(267) = r261", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r261" + ], + "range": { + "start": 24149, + "end": 24186 + } + }, + { + "id": "effect_307", + "effect_id": "effect@24211:24259", + "bound_var": "b262", + "source_text": "ctx.insert_t51_mul(sphi1.clone(), sphi2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "sphi1", + "sphi2" + ], + "range": { + "start": 24211, + "end": 24259 + } + }, + { + "id": "effect_308", + "effect_id": "effect@24284:24329", + "bound_var": "b263", + "source_text": "ctx.insert_t51_add(b17.clone(), b262.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b17", + "b262" + ], + "range": { + "start": 24284, + "end": 24329 + } + }, + { + "id": "effect_309", + "effect_id": "effect@24354:24399", + "bound_var": "b264", + "source_text": "ctx.insert_t51_add(b56.clone(), b262.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b262", + "b56" + ], + "range": { + "start": 24354, + "end": 24399 + } + }, + { + "id": "effect_310", + "effect_id": "effect@24424:24481", + "bound_var": "b265", + "source_text": "ctx.insert_t51_lower(b264.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b264" + ], + "range": { + "start": 24424, + "end": 24481 + } + }, + { + "id": "effect_311", + "effect_id": "effect@24506:24555", + "bound_var": "r266", + "source_text": "ctx.insert_t51_approx(b263.clone(), b265.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b263", + "b265" + ], + "range": { + "start": 24506, + "end": 24555 + } + }, + { + "id": "effect_312", + "effect_id": "effect@24569:24606", + "bound_var": null, + "source_text": "ctx.set_to_extract(272, r266.clone())", + "semantic_text": "to_extract(272) = r266", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r266" + ], + "range": { + "start": 24569, + "end": 24606 + } + }, + { + "id": "effect_313", + "effect_id": "effect@24631:24676", + "bound_var": "b267", + "source_text": "ctx.insert_t51_add(b61.clone(), b262.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b262", + "b61" + ], + "range": { + "start": 24631, + "end": 24676 + } + }, + { + "id": "effect_314", + "effect_id": "effect@24701:24746", + "bound_var": "b268", + "source_text": "ctx.insert_t51_add(b56.clone(), b267.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b267", + "b56" + ], + "range": { + "start": 24701, + "end": 24746 + } + }, + { + "id": "effect_315", + "effect_id": "effect@24771:24828", + "bound_var": "b269", + "source_text": "ctx.insert_t51_lower(b268.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b268" + ], + "range": { + "start": 24771, + "end": 24828 + } + }, + { + "id": "effect_316", + "effect_id": "effect@24853:24902", + "bound_var": "r270", + "source_text": "ctx.insert_t51_approx(b263.clone(), b269.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b263", + "b269" + ], + "range": { + "start": 24853, + "end": 24902 + } + }, + { + "id": "effect_317", + "effect_id": "effect@24916:24953", + "bound_var": null, + "source_text": "ctx.set_to_extract(276, r270.clone())", + "semantic_text": "to_extract(276) = r270", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r270" + ], + "range": { + "start": 24916, + "end": 24953 + } + }, + { + "id": "effect_318", + "effect_id": "effect@24978:25023", + "bound_var": "b271", + "source_text": "ctx.insert_t51_add(b69.clone(), b262.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b262", + "b69" + ], + "range": { + "start": 24978, + "end": 25023 + } + }, + { + "id": "effect_319", + "effect_id": "effect@25048:25093", + "bound_var": "b272", + "source_text": "ctx.insert_t51_add(b56.clone(), b271.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b271", + "b56" + ], + "range": { + "start": 25048, + "end": 25093 + } + }, + { + "id": "effect_320", + "effect_id": "effect@25118:25175", + "bound_var": "b273", + "source_text": "ctx.insert_t51_lower(b272.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b272" + ], + "range": { + "start": 25118, + "end": 25175 + } + }, + { + "id": "effect_321", + "effect_id": "effect@25200:25249", + "bound_var": "r274", + "source_text": "ctx.insert_t51_approx(b263.clone(), b273.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b263", + "b273" + ], + "range": { + "start": 25200, + "end": 25249 + } + }, + { + "id": "effect_322", + "effect_id": "effect@25263:25300", + "bound_var": null, + "source_text": "ctx.set_to_extract(280, r274.clone())", + "semantic_text": "to_extract(280) = r274", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r274" + ], + "range": { + "start": 25263, + "end": 25300 + } + }, + { + "id": "effect_323", + "effect_id": "effect@25325:25370", + "bound_var": "b275", + "source_text": "ctx.insert_t51_add(b79.clone(), b262.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b262", + "b79" + ], + "range": { + "start": 25325, + "end": 25370 + } + }, + { + "id": "effect_324", + "effect_id": "effect@25395:25440", + "bound_var": "b276", + "source_text": "ctx.insert_t51_add(b56.clone(), b275.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b275", + "b56" + ], + "range": { + "start": 25395, + "end": 25440 + } + }, + { + "id": "effect_325", + "effect_id": "effect@25465:25522", + "bound_var": "b277", + "source_text": "ctx.insert_t51_lower(b276.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b276" + ], + "range": { + "start": 25465, + "end": 25522 + } + }, + { + "id": "effect_326", + "effect_id": "effect@25547:25596", + "bound_var": "r278", + "source_text": "ctx.insert_t51_approx(b263.clone(), b277.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b263", + "b277" + ], + "range": { + "start": 25547, + "end": 25596 + } + }, + { + "id": "effect_327", + "effect_id": "effect@25610:25647", + "bound_var": null, + "source_text": "ctx.set_to_extract(284, r278.clone())", + "semantic_text": "to_extract(284) = r278", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r278" + ], + "range": { + "start": 25610, + "end": 25647 + } + }, + { + "id": "effect_328", + "effect_id": "effect@25672:25717", + "bound_var": "b279", + "source_text": "ctx.insert_t51_mul(sphi1.clone(), b9.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b9", + "sphi1" + ], + "range": { + "start": 25672, + "end": 25717 + } + }, + { + "id": "effect_329", + "effect_id": "effect@25742:25787", + "bound_var": "b280", + "source_text": "ctx.insert_t51_add(b279.clone(), b22.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b22", + "b279" + ], + "range": { + "start": 25742, + "end": 25787 + } + }, + { + "id": "effect_330", + "effect_id": "effect@25812:25858", + "bound_var": "b281", + "source_text": "ctx.insert_t51_add(b279.clone(), b185.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b185", + "b279" + ], + "range": { + "start": 25812, + "end": 25858 + } + }, + { + "id": "effect_331", + "effect_id": "effect@25883:25940", + "bound_var": "b282", + "source_text": "ctx.insert_t51_lower(b281.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b281" + ], + "range": { + "start": 25883, + "end": 25940 + } + }, + { + "id": "effect_332", + "effect_id": "effect@25965:26014", + "bound_var": "r283", + "source_text": "ctx.insert_t51_approx(b280.clone(), b282.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b280", + "b282" + ], + "range": { + "start": 25965, + "end": 26014 + } + }, + { + "id": "effect_333", + "effect_id": "effect@26028:26065", + "bound_var": null, + "source_text": "ctx.set_to_extract(289, r283.clone())", + "semantic_text": "to_extract(289) = r283", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r283" + ], + "range": { + "start": 26028, + "end": 26065 + } + }, + { + "id": "effect_334", + "effect_id": "effect@26090:26140", + "bound_var": "b284", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b189.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b189", + "slambda1" + ], + "range": { + "start": 26090, + "end": 26140 + } + }, + { + "id": "effect_335", + "effect_id": "effect@26165:26210", + "bound_var": "b285", + "source_text": "ctx.insert_t51_mul(b49.clone(), b284.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b284", + "b49" + ], + "range": { + "start": 26165, + "end": 26210 + } + }, + { + "id": "effect_336", + "effect_id": "effect@26235:26281", + "bound_var": "b286", + "source_text": "ctx.insert_t51_add(b285.clone(), b281.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b281", + "b285" + ], + "range": { + "start": 26235, + "end": 26281 + } + }, + { + "id": "effect_337", + "effect_id": "effect@26306:26363", + "bound_var": "b287", + "source_text": "ctx.insert_t51_lower(b286.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b286" + ], + "range": { + "start": 26306, + "end": 26363 + } + }, + { + "id": "effect_338", + "effect_id": "effect@26388:26437", + "bound_var": "r288", + "source_text": "ctx.insert_t51_approx(b280.clone(), b287.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b280", + "b287" + ], + "range": { + "start": 26388, + "end": 26437 + } + }, + { + "id": "effect_339", + "effect_id": "effect@26451:26488", + "bound_var": null, + "source_text": "ctx.set_to_extract(294, r288.clone())", + "semantic_text": "to_extract(294) = r288", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r288" + ], + "range": { + "start": 26451, + "end": 26488 + } + }, + { + "id": "effect_340", + "effect_id": "effect@26513:26558", + "bound_var": "b289", + "source_text": "ctx.insert_t51_mul(b49.clone(), b189.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b189", + "b49" + ], + "range": { + "start": 26513, + "end": 26558 + } + }, + { + "id": "effect_341", + "effect_id": "effect@26583:26633", + "bound_var": "b290", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b185.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b185", + "slambda1" + ], + "range": { + "start": 26583, + "end": 26633 + } + }, + { + "id": "effect_342", + "effect_id": "effect@26658:26703", + "bound_var": "b291", + "source_text": "ctx.insert_t51_mul(b65.clone(), b290.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b290", + "b65" + ], + "range": { + "start": 26658, + "end": 26703 + } + }, + { + "id": "effect_343", + "effect_id": "effect@26728:26774", + "bound_var": "b292", + "source_text": "ctx.insert_t51_add(b289.clone(), b291.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b289", + "b291" + ], + "range": { + "start": 26728, + "end": 26774 + } + }, + { + "id": "effect_344", + "effect_id": "effect@26799:26849", + "bound_var": "b293", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b292.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b292", + "slambda1" + ], + "range": { + "start": 26799, + "end": 26849 + } + }, + { + "id": "effect_345", + "effect_id": "effect@26874:26920", + "bound_var": "b294", + "source_text": "ctx.insert_t51_add(b293.clone(), b281.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b281", + "b293" + ], + "range": { + "start": 26874, + "end": 26920 + } + }, + { + "id": "effect_346", + "effect_id": "effect@26945:27002", + "bound_var": "b295", + "source_text": "ctx.insert_t51_lower(b294.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b294" + ], + "range": { + "start": 26945, + "end": 27002 + } + }, + { + "id": "effect_347", + "effect_id": "effect@27027:27076", + "bound_var": "r296", + "source_text": "ctx.insert_t51_approx(b280.clone(), b295.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b280", + "b295" + ], + "range": { + "start": 27027, + "end": 27076 + } + }, + { + "id": "effect_348", + "effect_id": "effect@27090:27127", + "bound_var": null, + "source_text": "ctx.set_to_extract(302, r296.clone())", + "semantic_text": "to_extract(302) = r296", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r296" + ], + "range": { + "start": 27090, + "end": 27127 + } + }, + { + "id": "effect_349", + "effect_id": "effect@27152:27197", + "bound_var": "b297", + "source_text": "ctx.insert_t51_mul(b65.clone(), b185.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b185", + "b65" + ], + "range": { + "start": 27152, + "end": 27197 + } + }, + { + "id": "effect_350", + "effect_id": "effect@27222:27267", + "bound_var": "b298", + "source_text": "ctx.insert_t51_mul(b74.clone(), b284.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b284", + "b74" + ], + "range": { + "start": 27222, + "end": 27267 + } + }, + { + "id": "effect_351", + "effect_id": "effect@27292:27338", + "bound_var": "b299", + "source_text": "ctx.insert_t51_add(b297.clone(), b298.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b297", + "b298" + ], + "range": { + "start": 27292, + "end": 27338 + } + }, + { + "id": "effect_352", + "effect_id": "effect@27363:27413", + "bound_var": "b300", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b299.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b299", + "slambda1" + ], + "range": { + "start": 27363, + "end": 27413 + } + }, + { + "id": "effect_353", + "effect_id": "effect@27438:27484", + "bound_var": "b301", + "source_text": "ctx.insert_t51_add(b289.clone(), b300.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b289", + "b300" + ], + "range": { + "start": 27438, + "end": 27484 + } + }, + { + "id": "effect_354", + "effect_id": "effect@27509:27559", + "bound_var": "b302", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b301.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b301", + "slambda1" + ], + "range": { + "start": 27509, + "end": 27559 + } + }, + { + "id": "effect_355", + "effect_id": "effect@27584:27630", + "bound_var": "b303", + "source_text": "ctx.insert_t51_add(b302.clone(), b281.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b281", + "b302" + ], + "range": { + "start": 27584, + "end": 27630 + } + }, + { + "id": "effect_356", + "effect_id": "effect@27655:27712", + "bound_var": "b304", + "source_text": "ctx.insert_t51_lower(b303.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b303" + ], + "range": { + "start": 27655, + "end": 27712 + } + }, + { + "id": "effect_357", + "effect_id": "effect@27737:27786", + "bound_var": "r305", + "source_text": "ctx.insert_t51_approx(b280.clone(), b304.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b280", + "b304" + ], + "range": { + "start": 27737, + "end": 27786 + } + }, + { + "id": "effect_358", + "effect_id": "effect@27800:27837", + "bound_var": null, + "source_text": "ctx.set_to_extract(311, r305.clone())", + "semantic_text": "to_extract(311) = r305", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r305" + ], + "range": { + "start": 27800, + "end": 27837 + } + }, + { + "id": "effect_359", + "effect_id": "effect@27862:27881", + "bound_var": "b306", + "source_text": "ctx.insert_t51_pi()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 27862, + "end": 27881 + } + }, + { + "id": "effect_360", + "effect_id": "effect@27906:27951", + "bound_var": "b307", + "source_text": "ctx.insert_t51_mul(b98.clone(), b306.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b306", + "b98" + ], + "range": { + "start": 27906, + "end": 27951 + } + }, + { + "id": "effect_361", + "effect_id": "effect@27976:28021", + "bound_var": "b308", + "source_text": "ctx.insert_t51_add(b307.clone(), b16.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b16", + "b307" + ], + "range": { + "start": 27976, + "end": 28021 + } + }, + { + "id": "effect_362", + "effect_id": "effect@28046:28096", + "bound_var": "b309", + "source_text": "ctx.insert_t51_sub(b307.clone(), slambda2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b307", + "slambda2" + ], + "range": { + "start": 28046, + "end": 28096 + } + }, + { + "id": "effect_363", + "effect_id": "effect@28121:28178", + "bound_var": "b310", + "source_text": "ctx.insert_t51_lower(b309.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b309" + ], + "range": { + "start": 28121, + "end": 28178 + } + }, + { + "id": "effect_364", + "effect_id": "effect@28203:28252", + "bound_var": "r311", + "source_text": "ctx.insert_t51_approx(b308.clone(), b310.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b308", + "b310" + ], + "range": { + "start": 28203, + "end": 28252 + } + }, + { + "id": "effect_365", + "effect_id": "effect@28266:28303", + "bound_var": null, + "source_text": "ctx.set_to_extract(317, r311.clone())", + "semantic_text": "to_extract(317) = r311", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r311" + ], + "range": { + "start": 28266, + "end": 28303 + } + }, + { + "id": "effect_366", + "effect_id": "effect@28328:28378", + "bound_var": "b312", + "source_text": "ctx.insert_t51_add(slambda1.clone(), b307.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b307", + "slambda1" + ], + "range": { + "start": 28328, + "end": 28378 + } + }, + { + "id": "effect_367", + "effect_id": "effect@28403:28453", + "bound_var": "b313", + "source_text": "ctx.insert_t51_sub(b312.clone(), slambda2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b312", + "slambda2" + ], + "range": { + "start": 28403, + "end": 28453 + } + }, + { + "id": "effect_368", + "effect_id": "effect@28478:28535", + "bound_var": "b314", + "source_text": "ctx.insert_t51_lower(b313.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b313" + ], + "range": { + "start": 28478, + "end": 28535 + } + }, + { + "id": "effect_369", + "effect_id": "effect@28560:28609", + "bound_var": "r315", + "source_text": "ctx.insert_t51_approx(b308.clone(), b314.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b308", + "b314" + ], + "range": { + "start": 28560, + "end": 28609 + } + }, + { + "id": "effect_370", + "effect_id": "effect@28623:28660", + "bound_var": null, + "source_text": "ctx.set_to_extract(321, r315.clone())", + "semantic_text": "to_extract(321) = r315", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r315" + ], + "range": { + "start": 28623, + "end": 28660 + } + }, + { + "id": "effect_371", + "effect_id": "effect@28685:28732", + "bound_var": "b316", + "source_text": "ctx.insert_t51_sub(b308.clone(), sphi2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b308", + "sphi2" + ], + "range": { + "start": 28685, + "end": 28732 + } + }, + { + "id": "effect_372", + "effect_id": "effect@28757:28808", + "bound_var": "b317", + "source_text": "ctx.insert_t51_add(slambda2.clone(), sphi2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "slambda2", + "sphi2" + ], + "range": { + "start": 28757, + "end": 28808 + } + }, + { + "id": "effect_373", + "effect_id": "effect@28833:28879", + "bound_var": "b318", + "source_text": "ctx.insert_t51_sub(b307.clone(), b317.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b307", + "b317" + ], + "range": { + "start": 28833, + "end": 28879 + } + }, + { + "id": "effect_374", + "effect_id": "effect@28904:28961", + "bound_var": "b319", + "source_text": "ctx.insert_t51_lower(b318.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b318" + ], + "range": { + "start": 28904, + "end": 28961 + } + }, + { + "id": "effect_375", + "effect_id": "effect@28986:29035", + "bound_var": "r320", + "source_text": "ctx.insert_t51_approx(b316.clone(), b319.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b316", + "b319" + ], + "range": { + "start": 28986, + "end": 29035 + } + }, + { + "id": "effect_376", + "effect_id": "effect@29049:29086", + "bound_var": null, + "source_text": "ctx.set_to_extract(326, r320.clone())", + "semantic_text": "to_extract(326) = r320", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r320" + ], + "range": { + "start": 29049, + "end": 29086 + } + }, + { + "id": "effect_377", + "effect_id": "effect@29111:29157", + "bound_var": "b321", + "source_text": "ctx.insert_t51_sub(b312.clone(), b317.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b312", + "b317" + ], + "range": { + "start": 29111, + "end": 29157 + } + }, + { + "id": "effect_378", + "effect_id": "effect@29182:29239", + "bound_var": "b322", + "source_text": "ctx.insert_t51_lower(b321.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b321" + ], + "range": { + "start": 29182, + "end": 29239 + } + }, + { + "id": "effect_379", + "effect_id": "effect@29264:29313", + "bound_var": "r323", + "source_text": "ctx.insert_t51_approx(b316.clone(), b322.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b316", + "b322" + ], + "range": { + "start": 29264, + "end": 29313 + } + }, + { + "id": "effect_380", + "effect_id": "effect@29327:29364", + "bound_var": null, + "source_text": "ctx.set_to_extract(329, r323.clone())", + "semantic_text": "to_extract(329) = r323", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r323" + ], + "range": { + "start": 29327, + "end": 29364 + } + }, + { + "id": "effect_381", + "effect_id": "effect@29389:29421", + "bound_var": "b324", + "source_text": "ctx.insert_t51_sin(b316.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b316" + ], + "range": { + "start": 29389, + "end": 29421 + } + }, + { + "id": "effect_382", + "effect_id": "effect@29446:29478", + "bound_var": "b325", + "source_text": "ctx.insert_t51_sin(b318.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b318" + ], + "range": { + "start": 29446, + "end": 29478 + } + }, + { + "id": "effect_383", + "effect_id": "effect@29503:29560", + "bound_var": "b326", + "source_text": "ctx.insert_t51_lower(b325.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b325" + ], + "range": { + "start": 29503, + "end": 29560 + } + }, + { + "id": "effect_384", + "effect_id": "effect@29585:29634", + "bound_var": "r327", + "source_text": "ctx.insert_t51_approx(b324.clone(), b326.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b324", + "b326" + ], + "range": { + "start": 29585, + "end": 29634 + } + }, + { + "id": "effect_385", + "effect_id": "effect@29648:29685", + "bound_var": null, + "source_text": "ctx.set_to_extract(333, r327.clone())", + "semantic_text": "to_extract(333) = r327", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r327" + ], + "range": { + "start": 29648, + "end": 29685 + } + }, + { + "id": "effect_386", + "effect_id": "effect@29710:29742", + "bound_var": "b328", + "source_text": "ctx.insert_t51_cos(b318.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b318" + ], + "range": { + "start": 29710, + "end": 29742 + } + }, + { + "id": "effect_387", + "effect_id": "effect@29767:29817", + "bound_var": "b329", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b328.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b328", + "slambda1" + ], + "range": { + "start": 29767, + "end": 29817 + } + }, + { + "id": "effect_388", + "effect_id": "effect@29842:29888", + "bound_var": "b330", + "source_text": "ctx.insert_t51_add(b325.clone(), b329.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b325", + "b329" + ], + "range": { + "start": 29842, + "end": 29888 + } + }, + { + "id": "effect_389", + "effect_id": "effect@29913:29970", + "bound_var": "b331", + "source_text": "ctx.insert_t51_lower(b330.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b330" + ], + "range": { + "start": 29913, + "end": 29970 + } + }, + { + "id": "effect_390", + "effect_id": "effect@29995:30044", + "bound_var": "r332", + "source_text": "ctx.insert_t51_approx(b324.clone(), b331.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b324", + "b331" + ], + "range": { + "start": 29995, + "end": 30044 + } + }, + { + "id": "effect_391", + "effect_id": "effect@30058:30095", + "bound_var": null, + "source_text": "ctx.set_to_extract(338, r332.clone())", + "semantic_text": "to_extract(338) = r332", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r332" + ], + "range": { + "start": 30058, + "end": 30095 + } + }, + { + "id": "effect_392", + "effect_id": "effect@30120:30170", + "bound_var": "b333", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b325.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b325", + "slambda1" + ], + "range": { + "start": 30120, + "end": 30170 + } + }, + { + "id": "effect_393", + "effect_id": "effect@30195:30240", + "bound_var": "b334", + "source_text": "ctx.insert_t51_mul(b65.clone(), b333.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b333", + "b65" + ], + "range": { + "start": 30195, + "end": 30240 + } + }, + { + "id": "effect_394", + "effect_id": "effect@30265:30311", + "bound_var": "b335", + "source_text": "ctx.insert_t51_add(b328.clone(), b334.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b328", + "b334" + ], + "range": { + "start": 30265, + "end": 30311 + } + }, + { + "id": "effect_395", + "effect_id": "effect@30336:30386", + "bound_var": "b336", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b335.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b335", + "slambda1" + ], + "range": { + "start": 30336, + "end": 30386 + } + }, + { + "id": "effect_396", + "effect_id": "effect@30411:30457", + "bound_var": "b337", + "source_text": "ctx.insert_t51_add(b325.clone(), b336.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b325", + "b336" + ], + "range": { + "start": 30411, + "end": 30457 + } + }, + { + "id": "effect_397", + "effect_id": "effect@30482:30539", + "bound_var": "b338", + "source_text": "ctx.insert_t51_lower(b337.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b337" + ], + "range": { + "start": 30482, + "end": 30539 + } + }, + { + "id": "effect_398", + "effect_id": "effect@30564:30613", + "bound_var": "r339", + "source_text": "ctx.insert_t51_approx(b324.clone(), b338.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b324", + "b338" + ], + "range": { + "start": 30564, + "end": 30613 + } + }, + { + "id": "effect_399", + "effect_id": "effect@30627:30664", + "bound_var": null, + "source_text": "ctx.set_to_extract(345, r339.clone())", + "semantic_text": "to_extract(345) = r339", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r339" + ], + "range": { + "start": 30627, + "end": 30664 + } + }, + { + "id": "effect_400", + "effect_id": "effect@30689:30734", + "bound_var": "b340", + "source_text": "ctx.insert_t51_mul(b65.clone(), b325.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b325", + "b65" + ], + "range": { + "start": 30689, + "end": 30734 + } + }, + { + "id": "effect_401", + "effect_id": "effect@30759:30805", + "bound_var": "b341", + "source_text": "ctx.insert_t51_mul(b113.clone(), b329.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b329" + ], + "range": { + "start": 30759, + "end": 30805 + } + }, + { + "id": "effect_402", + "effect_id": "effect@30830:30876", + "bound_var": "b342", + "source_text": "ctx.insert_t51_add(b340.clone(), b341.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b340", + "b341" + ], + "range": { + "start": 30830, + "end": 30876 + } + }, + { + "id": "effect_403", + "effect_id": "effect@30901:30951", + "bound_var": "b343", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b342.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b342", + "slambda1" + ], + "range": { + "start": 30901, + "end": 30951 + } + }, + { + "id": "effect_404", + "effect_id": "effect@30976:31022", + "bound_var": "b344", + "source_text": "ctx.insert_t51_add(b328.clone(), b343.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b328", + "b343" + ], + "range": { + "start": 30976, + "end": 31022 + } + }, + { + "id": "effect_405", + "effect_id": "effect@31047:31097", + "bound_var": "b345", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b344.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b344", + "slambda1" + ], + "range": { + "start": 31047, + "end": 31097 + } + }, + { + "id": "effect_406", + "effect_id": "effect@31122:31168", + "bound_var": "b346", + "source_text": "ctx.insert_t51_add(b325.clone(), b345.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b325", + "b345" + ], + "range": { + "start": 31122, + "end": 31168 + } + }, + { + "id": "effect_407", + "effect_id": "effect@31193:31250", + "bound_var": "b347", + "source_text": "ctx.insert_t51_lower(b346.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b346" + ], + "range": { + "start": 31193, + "end": 31250 + } + }, + { + "id": "effect_408", + "effect_id": "effect@31275:31324", + "bound_var": "r348", + "source_text": "ctx.insert_t51_approx(b324.clone(), b347.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b324", + "b347" + ], + "range": { + "start": 31275, + "end": 31324 + } + }, + { + "id": "effect_409", + "effect_id": "effect@31338:31375", + "bound_var": null, + "source_text": "ctx.set_to_extract(354, r348.clone())", + "semantic_text": "to_extract(354) = r348", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r348" + ], + "range": { + "start": 31338, + "end": 31375 + } + }, + { + "id": "effect_410", + "effect_id": "effect@31400:31447", + "bound_var": "b349", + "source_text": "ctx.insert_t51_add(b308.clone(), sphi2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b308", + "sphi2" + ], + "range": { + "start": 31400, + "end": 31447 + } + }, + { + "id": "effect_411", + "effect_id": "effect@31472:31519", + "bound_var": "b350", + "source_text": "ctx.insert_t51_add(sphi2.clone(), b307.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b307", + "sphi2" + ], + "range": { + "start": 31472, + "end": 31519 + } + }, + { + "id": "effect_412", + "effect_id": "effect@31544:31594", + "bound_var": "b351", + "source_text": "ctx.insert_t51_sub(b350.clone(), slambda2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b350", + "slambda2" + ], + "range": { + "start": 31544, + "end": 31594 + } + }, + { + "id": "effect_413", + "effect_id": "effect@31619:31676", + "bound_var": "b352", + "source_text": "ctx.insert_t51_lower(b351.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b351" + ], + "range": { + "start": 31619, + "end": 31676 + } + }, + { + "id": "effect_414", + "effect_id": "effect@31701:31750", + "bound_var": "r353", + "source_text": "ctx.insert_t51_approx(b349.clone(), b352.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b349", + "b352" + ], + "range": { + "start": 31701, + "end": 31750 + } + }, + { + "id": "effect_415", + "effect_id": "effect@31764:31801", + "bound_var": null, + "source_text": "ctx.set_to_extract(359, r353.clone())", + "semantic_text": "to_extract(359) = r353", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r353" + ], + "range": { + "start": 31764, + "end": 31801 + } + }, + { + "id": "effect_416", + "effect_id": "effect@31826:31876", + "bound_var": "b354", + "source_text": "ctx.insert_t51_add(slambda1.clone(), b350.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b350", + "slambda1" + ], + "range": { + "start": 31826, + "end": 31876 + } + }, + { + "id": "effect_417", + "effect_id": "effect@31901:31951", + "bound_var": "b355", + "source_text": "ctx.insert_t51_sub(b354.clone(), slambda2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b354", + "slambda2" + ], + "range": { + "start": 31901, + "end": 31951 + } + }, + { + "id": "effect_418", + "effect_id": "effect@31976:32033", + "bound_var": "b356", + "source_text": "ctx.insert_t51_lower(b355.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b355" + ], + "range": { + "start": 31976, + "end": 32033 + } + }, + { + "id": "effect_419", + "effect_id": "effect@32058:32107", + "bound_var": "r357", + "source_text": "ctx.insert_t51_approx(b349.clone(), b356.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b349", + "b356" + ], + "range": { + "start": 32058, + "end": 32107 + } + }, + { + "id": "effect_420", + "effect_id": "effect@32121:32158", + "bound_var": null, + "source_text": "ctx.set_to_extract(363, r357.clone())", + "semantic_text": "to_extract(363) = r357", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r357" + ], + "range": { + "start": 32121, + "end": 32158 + } + }, + { + "id": "effect_421", + "effect_id": "effect@32183:32215", + "bound_var": "b358", + "source_text": "ctx.insert_t51_sin(b349.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b349" + ], + "range": { + "start": 32183, + "end": 32215 + } + }, + { + "id": "effect_422", + "effect_id": "effect@32240:32272", + "bound_var": "b359", + "source_text": "ctx.insert_t51_sin(b351.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b351" + ], + "range": { + "start": 32240, + "end": 32272 + } + }, + { + "id": "effect_423", + "effect_id": "effect@32297:32354", + "bound_var": "b360", + "source_text": "ctx.insert_t51_lower(b359.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b359" + ], + "range": { + "start": 32297, + "end": 32354 + } + }, + { + "id": "effect_424", + "effect_id": "effect@32379:32428", + "bound_var": "r361", + "source_text": "ctx.insert_t51_approx(b358.clone(), b360.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b358", + "b360" + ], + "range": { + "start": 32379, + "end": 32428 + } + }, + { + "id": "effect_425", + "effect_id": "effect@32442:32479", + "bound_var": null, + "source_text": "ctx.set_to_extract(367, r361.clone())", + "semantic_text": "to_extract(367) = r361", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r361" + ], + "range": { + "start": 32442, + "end": 32479 + } + }, + { + "id": "effect_426", + "effect_id": "effect@32504:32536", + "bound_var": "b362", + "source_text": "ctx.insert_t51_cos(b351.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b351" + ], + "range": { + "start": 32504, + "end": 32536 + } + }, + { + "id": "effect_427", + "effect_id": "effect@32561:32611", + "bound_var": "b363", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b362.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b362", + "slambda1" + ], + "range": { + "start": 32561, + "end": 32611 + } + }, + { + "id": "effect_428", + "effect_id": "effect@32636:32682", + "bound_var": "b364", + "source_text": "ctx.insert_t51_add(b359.clone(), b363.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b359", + "b363" + ], + "range": { + "start": 32636, + "end": 32682 + } + }, + { + "id": "effect_429", + "effect_id": "effect@32707:32764", + "bound_var": "b365", + "source_text": "ctx.insert_t51_lower(b364.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b364" + ], + "range": { + "start": 32707, + "end": 32764 + } + }, + { + "id": "effect_430", + "effect_id": "effect@32789:32838", + "bound_var": "r366", + "source_text": "ctx.insert_t51_approx(b358.clone(), b365.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b358", + "b365" + ], + "range": { + "start": 32789, + "end": 32838 + } + }, + { + "id": "effect_431", + "effect_id": "effect@32852:32889", + "bound_var": null, + "source_text": "ctx.set_to_extract(372, r366.clone())", + "semantic_text": "to_extract(372) = r366", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r366" + ], + "range": { + "start": 32852, + "end": 32889 + } + }, + { + "id": "effect_432", + "effect_id": "effect@32914:32964", + "bound_var": "b367", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b359.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b359", + "slambda1" + ], + "range": { + "start": 32914, + "end": 32964 + } + }, + { + "id": "effect_433", + "effect_id": "effect@32989:33034", + "bound_var": "b368", + "source_text": "ctx.insert_t51_mul(b65.clone(), b367.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b367", + "b65" + ], + "range": { + "start": 32989, + "end": 33034 + } + }, + { + "id": "effect_434", + "effect_id": "effect@33059:33105", + "bound_var": "b369", + "source_text": "ctx.insert_t51_add(b362.clone(), b368.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b362", + "b368" + ], + "range": { + "start": 33059, + "end": 33105 + } + }, + { + "id": "effect_435", + "effect_id": "effect@33130:33180", + "bound_var": "b370", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b369.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b369", + "slambda1" + ], + "range": { + "start": 33130, + "end": 33180 + } + }, + { + "id": "effect_436", + "effect_id": "effect@33205:33251", + "bound_var": "b371", + "source_text": "ctx.insert_t51_add(b359.clone(), b370.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b359", + "b370" + ], + "range": { + "start": 33205, + "end": 33251 + } + }, + { + "id": "effect_437", + "effect_id": "effect@33276:33333", + "bound_var": "b372", + "source_text": "ctx.insert_t51_lower(b371.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b371" + ], + "range": { + "start": 33276, + "end": 33333 + } + }, + { + "id": "effect_438", + "effect_id": "effect@33358:33407", + "bound_var": "r373", + "source_text": "ctx.insert_t51_approx(b358.clone(), b372.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b358", + "b372" + ], + "range": { + "start": 33358, + "end": 33407 + } + }, + { + "id": "effect_439", + "effect_id": "effect@33421:33458", + "bound_var": null, + "source_text": "ctx.set_to_extract(379, r373.clone())", + "semantic_text": "to_extract(379) = r373", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r373" + ], + "range": { + "start": 33421, + "end": 33458 + } + }, + { + "id": "effect_440", + "effect_id": "effect@33483:33528", + "bound_var": "b374", + "source_text": "ctx.insert_t51_mul(b65.clone(), b359.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b359", + "b65" + ], + "range": { + "start": 33483, + "end": 33528 + } + }, + { + "id": "effect_441", + "effect_id": "effect@33553:33599", + "bound_var": "b375", + "source_text": "ctx.insert_t51_mul(b113.clone(), b363.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b363" + ], + "range": { + "start": 33553, + "end": 33599 + } + }, + { + "id": "effect_442", + "effect_id": "effect@33624:33670", + "bound_var": "b376", + "source_text": "ctx.insert_t51_add(b374.clone(), b375.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b374", + "b375" + ], + "range": { + "start": 33624, + "end": 33670 + } + }, + { + "id": "effect_443", + "effect_id": "effect@33695:33745", + "bound_var": "b377", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b376.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b376", + "slambda1" + ], + "range": { + "start": 33695, + "end": 33745 + } + }, + { + "id": "effect_444", + "effect_id": "effect@33770:33816", + "bound_var": "b378", + "source_text": "ctx.insert_t51_add(b362.clone(), b377.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b362", + "b377" + ], + "range": { + "start": 33770, + "end": 33816 + } + }, + { + "id": "effect_445", + "effect_id": "effect@33841:33891", + "bound_var": "b379", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b378.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b378", + "slambda1" + ], + "range": { + "start": 33841, + "end": 33891 + } + }, + { + "id": "effect_446", + "effect_id": "effect@33916:33962", + "bound_var": "b380", + "source_text": "ctx.insert_t51_add(b359.clone(), b379.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b359", + "b379" + ], + "range": { + "start": 33916, + "end": 33962 + } + }, + { + "id": "effect_447", + "effect_id": "effect@33987:34044", + "bound_var": "b381", + "source_text": "ctx.insert_t51_lower(b380.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b380" + ], + "range": { + "start": 33987, + "end": 34044 + } + }, + { + "id": "effect_448", + "effect_id": "effect@34069:34118", + "bound_var": "r382", + "source_text": "ctx.insert_t51_approx(b358.clone(), b381.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b358", + "b381" + ], + "range": { + "start": 34069, + "end": 34118 + } + }, + { + "id": "effect_449", + "effect_id": "effect@34132:34169", + "bound_var": null, + "source_text": "ctx.set_to_extract(388, r382.clone())", + "semantic_text": "to_extract(388) = r382", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r382" + ], + "range": { + "start": 34132, + "end": 34169 + } + }, + { + "id": "effect_450", + "effect_id": "effect@34194:34240", + "bound_var": "b383", + "source_text": "ctx.insert_t51_add(b324.clone(), b358.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b324", + "b358" + ], + "range": { + "start": 34194, + "end": 34240 + } + }, + { + "id": "effect_451", + "effect_id": "effect@34265:34311", + "bound_var": "b384", + "source_text": "ctx.insert_t51_add(b325.clone(), b359.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b325", + "b359" + ], + "range": { + "start": 34265, + "end": 34311 + } + }, + { + "id": "effect_452", + "effect_id": "effect@34336:34393", + "bound_var": "b385", + "source_text": "ctx.insert_t51_lower(b384.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b384" + ], + "range": { + "start": 34336, + "end": 34393 + } + }, + { + "id": "effect_453", + "effect_id": "effect@34418:34467", + "bound_var": "r386", + "source_text": "ctx.insert_t51_approx(b383.clone(), b385.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b383", + "b385" + ], + "range": { + "start": 34418, + "end": 34467 + } + }, + { + "id": "effect_454", + "effect_id": "effect@34481:34518", + "bound_var": null, + "source_text": "ctx.set_to_extract(392, r386.clone())", + "semantic_text": "to_extract(392) = r386", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r386" + ], + "range": { + "start": 34481, + "end": 34518 + } + }, + { + "id": "effect_455", + "effect_id": "effect@34543:34589", + "bound_var": "b387", + "source_text": "ctx.insert_t51_add(b328.clone(), b362.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b328", + "b362" + ], + "range": { + "start": 34543, + "end": 34589 + } + }, + { + "id": "effect_456", + "effect_id": "effect@34614:34664", + "bound_var": "b388", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b387.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b387", + "slambda1" + ], + "range": { + "start": 34614, + "end": 34664 + } + }, + { + "id": "effect_457", + "effect_id": "effect@34689:34735", + "bound_var": "b389", + "source_text": "ctx.insert_t51_add(b359.clone(), b388.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b359", + "b388" + ], + "range": { + "start": 34689, + "end": 34735 + } + }, + { + "id": "effect_458", + "effect_id": "effect@34760:34806", + "bound_var": "b390", + "source_text": "ctx.insert_t51_add(b325.clone(), b389.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b325", + "b389" + ], + "range": { + "start": 34760, + "end": 34806 + } + }, + { + "id": "effect_459", + "effect_id": "effect@34831:34888", + "bound_var": "b391", + "source_text": "ctx.insert_t51_lower(b390.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b390" + ], + "range": { + "start": 34831, + "end": 34888 + } + }, + { + "id": "effect_460", + "effect_id": "effect@34913:34962", + "bound_var": "r392", + "source_text": "ctx.insert_t51_approx(b383.clone(), b391.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b383", + "b391" + ], + "range": { + "start": 34913, + "end": 34962 + } + }, + { + "id": "effect_461", + "effect_id": "effect@34976:35013", + "bound_var": null, + "source_text": "ctx.set_to_extract(398, r392.clone())", + "semantic_text": "to_extract(398) = r392", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r392" + ], + "range": { + "start": 34976, + "end": 35013 + } + }, + { + "id": "effect_462", + "effect_id": "effect@35038:35084", + "bound_var": "b393", + "source_text": "ctx.insert_t51_add(b340.clone(), b374.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b340", + "b374" + ], + "range": { + "start": 35038, + "end": 35084 + } + }, + { + "id": "effect_463", + "effect_id": "effect@35109:35159", + "bound_var": "b394", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b393.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b393", + "slambda1" + ], + "range": { + "start": 35109, + "end": 35159 + } + }, + { + "id": "effect_464", + "effect_id": "effect@35184:35230", + "bound_var": "b395", + "source_text": "ctx.insert_t51_add(b362.clone(), b394.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b362", + "b394" + ], + "range": { + "start": 35184, + "end": 35230 + } + }, + { + "id": "effect_465", + "effect_id": "effect@35255:35301", + "bound_var": "b396", + "source_text": "ctx.insert_t51_add(b328.clone(), b395.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b328", + "b395" + ], + "range": { + "start": 35255, + "end": 35301 + } + }, + { + "id": "effect_466", + "effect_id": "effect@35326:35376", + "bound_var": "b397", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b396.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b396", + "slambda1" + ], + "range": { + "start": 35326, + "end": 35376 + } + }, + { + "id": "effect_467", + "effect_id": "effect@35401:35447", + "bound_var": "b398", + "source_text": "ctx.insert_t51_add(b359.clone(), b397.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b359", + "b397" + ], + "range": { + "start": 35401, + "end": 35447 + } + }, + { + "id": "effect_468", + "effect_id": "effect@35472:35518", + "bound_var": "b399", + "source_text": "ctx.insert_t51_add(b325.clone(), b398.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b325", + "b398" + ], + "range": { + "start": 35472, + "end": 35518 + } + }, + { + "id": "effect_469", + "effect_id": "effect@35543:35600", + "bound_var": "b400", + "source_text": "ctx.insert_t51_lower(b399.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b399" + ], + "range": { + "start": 35543, + "end": 35600 + } + }, + { + "id": "effect_470", + "effect_id": "effect@35625:35674", + "bound_var": "r401", + "source_text": "ctx.insert_t51_approx(b383.clone(), b400.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b383", + "b400" + ], + "range": { + "start": 35625, + "end": 35674 + } + }, + { + "id": "effect_471", + "effect_id": "effect@35688:35725", + "bound_var": null, + "source_text": "ctx.set_to_extract(407, r401.clone())", + "semantic_text": "to_extract(407) = r401", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r401" + ], + "range": { + "start": 35688, + "end": 35725 + } + }, + { + "id": "effect_472", + "effect_id": "effect@35750:35796", + "bound_var": "b402", + "source_text": "ctx.insert_t51_mul(b113.clone(), b328.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b328" + ], + "range": { + "start": 35750, + "end": 35796 + } + }, + { + "id": "effect_473", + "effect_id": "effect@35821:35867", + "bound_var": "b403", + "source_text": "ctx.insert_t51_mul(b113.clone(), b362.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b362" + ], + "range": { + "start": 35821, + "end": 35867 + } + }, + { + "id": "effect_474", + "effect_id": "effect@35892:35938", + "bound_var": "b404", + "source_text": "ctx.insert_t51_add(b402.clone(), b403.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b402", + "b403" + ], + "range": { + "start": 35892, + "end": 35938 + } + }, + { + "id": "effect_475", + "effect_id": "effect@35963:36013", + "bound_var": "b405", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b404.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b404", + "slambda1" + ], + "range": { + "start": 35963, + "end": 36013 + } + }, + { + "id": "effect_476", + "effect_id": "effect@36038:36084", + "bound_var": "b406", + "source_text": "ctx.insert_t51_add(b374.clone(), b405.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b374", + "b405" + ], + "range": { + "start": 36038, + "end": 36084 + } + }, + { + "id": "effect_477", + "effect_id": "effect@36109:36155", + "bound_var": "b407", + "source_text": "ctx.insert_t51_add(b340.clone(), b406.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b340", + "b406" + ], + "range": { + "start": 36109, + "end": 36155 + } + }, + { + "id": "effect_478", + "effect_id": "effect@36180:36230", + "bound_var": "b408", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b407.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b407", + "slambda1" + ], + "range": { + "start": 36180, + "end": 36230 + } + }, + { + "id": "effect_479", + "effect_id": "effect@36255:36301", + "bound_var": "b409", + "source_text": "ctx.insert_t51_add(b362.clone(), b408.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b362", + "b408" + ], + "range": { + "start": 36255, + "end": 36301 + } + }, + { + "id": "effect_480", + "effect_id": "effect@36326:36372", + "bound_var": "b410", + "source_text": "ctx.insert_t51_add(b328.clone(), b409.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b328", + "b409" + ], + "range": { + "start": 36326, + "end": 36372 + } + }, + { + "id": "effect_481", + "effect_id": "effect@36397:36447", + "bound_var": "b411", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b410.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b410", + "slambda1" + ], + "range": { + "start": 36397, + "end": 36447 + } + }, + { + "id": "effect_482", + "effect_id": "effect@36472:36518", + "bound_var": "b412", + "source_text": "ctx.insert_t51_add(b359.clone(), b411.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b359", + "b411" + ], + "range": { + "start": 36472, + "end": 36518 + } + }, + { + "id": "effect_483", + "effect_id": "effect@36543:36589", + "bound_var": "b413", + "source_text": "ctx.insert_t51_add(b325.clone(), b412.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b325", + "b412" + ], + "range": { + "start": 36543, + "end": 36589 + } + }, + { + "id": "effect_484", + "effect_id": "effect@36614:36671", + "bound_var": "b414", + "source_text": "ctx.insert_t51_lower(b413.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b413" + ], + "range": { + "start": 36614, + "end": 36671 + } + }, + { + "id": "effect_485", + "effect_id": "effect@36696:36745", + "bound_var": "r415", + "source_text": "ctx.insert_t51_approx(b383.clone(), b414.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b383", + "b414" + ], + "range": { + "start": 36696, + "end": 36745 + } + }, + { + "id": "effect_486", + "effect_id": "effect@36759:36796", + "bound_var": null, + "source_text": "ctx.set_to_extract(421, r415.clone())", + "semantic_text": "to_extract(421) = r415", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r415" + ], + "range": { + "start": 36759, + "end": 36796 + } + }, + { + "id": "effect_487", + "effect_id": "effect@36821:36866", + "bound_var": "b416", + "source_text": "ctx.insert_t51_div(b383.clone(), b90.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b383", + "b90" + ], + "range": { + "start": 36821, + "end": 36866 + } + }, + { + "id": "effect_488", + "effect_id": "effect@36891:36936", + "bound_var": "b417", + "source_text": "ctx.insert_t51_mul(b98.clone(), b384.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b384", + "b98" + ], + "range": { + "start": 36891, + "end": 36936 + } + }, + { + "id": "effect_489", + "effect_id": "effect@36961:37018", + "bound_var": "b418", + "source_text": "ctx.insert_t51_lower(b417.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b417" + ], + "range": { + "start": 36961, + "end": 37018 + } + }, + { + "id": "effect_490", + "effect_id": "effect@37043:37092", + "bound_var": "r419", + "source_text": "ctx.insert_t51_approx(b416.clone(), b418.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b416", + "b418" + ], + "range": { + "start": 37043, + "end": 37092 + } + }, + { + "id": "effect_491", + "effect_id": "effect@37106:37143", + "bound_var": null, + "source_text": "ctx.set_to_extract(425, r419.clone())", + "semantic_text": "to_extract(425) = r419", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r419" + ], + "range": { + "start": 37106, + "end": 37143 + } + }, + { + "id": "effect_492", + "effect_id": "effect@37168:37213", + "bound_var": "b420", + "source_text": "ctx.insert_t51_mul(b98.clone(), b388.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b388", + "b98" + ], + "range": { + "start": 37168, + "end": 37213 + } + }, + { + "id": "effect_493", + "effect_id": "effect@37238:37284", + "bound_var": "b421", + "source_text": "ctx.insert_t51_add(b420.clone(), b417.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b417", + "b420" + ], + "range": { + "start": 37238, + "end": 37284 + } + }, + { + "id": "effect_494", + "effect_id": "effect@37309:37366", + "bound_var": "b422", + "source_text": "ctx.insert_t51_lower(b421.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b421" + ], + "range": { + "start": 37309, + "end": 37366 + } + }, + { + "id": "effect_495", + "effect_id": "effect@37391:37440", + "bound_var": "r423", + "source_text": "ctx.insert_t51_approx(b416.clone(), b422.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b416", + "b422" + ], + "range": { + "start": 37391, + "end": 37440 + } + }, + { + "id": "effect_496", + "effect_id": "effect@37454:37491", + "bound_var": null, + "source_text": "ctx.set_to_extract(429, r423.clone())", + "semantic_text": "to_extract(429) = r423", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r423" + ], + "range": { + "start": 37454, + "end": 37491 + } + }, + { + "id": "effect_497", + "effect_id": "effect@37516:37561", + "bound_var": "b424", + "source_text": "ctx.insert_t51_mul(b98.clone(), b394.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b394", + "b98" + ], + "range": { + "start": 37516, + "end": 37561 + } + }, + { + "id": "effect_498", + "effect_id": "effect@37586:37631", + "bound_var": "b425", + "source_text": "ctx.insert_t51_mul(b98.clone(), b387.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b387", + "b98" + ], + "range": { + "start": 37586, + "end": 37631 + } + }, + { + "id": "effect_499", + "effect_id": "effect@37656:37702", + "bound_var": "b426", + "source_text": "ctx.insert_t51_add(b424.clone(), b425.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b424", + "b425" + ], + "range": { + "start": 37656, + "end": 37702 + } + }, + { + "id": "effect_500", + "effect_id": "effect@37727:37777", + "bound_var": "b427", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b426.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b426", + "slambda1" + ], + "range": { + "start": 37727, + "end": 37777 + } + }, + { + "id": "effect_501", + "effect_id": "effect@37802:37848", + "bound_var": "b428", + "source_text": "ctx.insert_t51_add(b417.clone(), b427.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b417", + "b427" + ], + "range": { + "start": 37802, + "end": 37848 + } + }, + { + "id": "effect_502", + "effect_id": "effect@37873:37930", + "bound_var": "b429", + "source_text": "ctx.insert_t51_lower(b428.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b428" + ], + "range": { + "start": 37873, + "end": 37930 + } + }, + { + "id": "effect_503", + "effect_id": "effect@37955:38004", + "bound_var": "r430", + "source_text": "ctx.insert_t51_approx(b416.clone(), b429.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b416", + "b429" + ], + "range": { + "start": 37955, + "end": 38004 + } + }, + { + "id": "effect_504", + "effect_id": "effect@38018:38055", + "bound_var": null, + "source_text": "ctx.set_to_extract(436, r430.clone())", + "semantic_text": "to_extract(436) = r430", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r430" + ], + "range": { + "start": 38018, + "end": 38055 + } + }, + { + "id": "effect_505", + "effect_id": "effect@38080:38125", + "bound_var": "b431", + "source_text": "ctx.insert_t51_mul(b98.clone(), b405.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b405", + "b98" + ], + "range": { + "start": 38080, + "end": 38125 + } + }, + { + "id": "effect_506", + "effect_id": "effect@38150:38195", + "bound_var": "b432", + "source_text": "ctx.insert_t51_mul(b98.clone(), b393.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b393", + "b98" + ], + "range": { + "start": 38150, + "end": 38195 + } + }, + { + "id": "effect_507", + "effect_id": "effect@38220:38266", + "bound_var": "b433", + "source_text": "ctx.insert_t51_add(b431.clone(), b432.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b431", + "b432" + ], + "range": { + "start": 38220, + "end": 38266 + } + }, + { + "id": "effect_508", + "effect_id": "effect@38291:38341", + "bound_var": "b434", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b433.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b433", + "slambda1" + ], + "range": { + "start": 38291, + "end": 38341 + } + }, + { + "id": "effect_509", + "effect_id": "effect@38366:38412", + "bound_var": "b435", + "source_text": "ctx.insert_t51_add(b425.clone(), b434.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b425", + "b434" + ], + "range": { + "start": 38366, + "end": 38412 + } + }, + { + "id": "effect_510", + "effect_id": "effect@38437:38487", + "bound_var": "b436", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b435.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b435", + "slambda1" + ], + "range": { + "start": 38437, + "end": 38487 + } + }, + { + "id": "effect_511", + "effect_id": "effect@38512:38558", + "bound_var": "b437", + "source_text": "ctx.insert_t51_add(b417.clone(), b436.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b417", + "b436" + ], + "range": { + "start": 38512, + "end": 38558 + } + }, + { + "id": "effect_512", + "effect_id": "effect@38583:38640", + "bound_var": "b438", + "source_text": "ctx.insert_t51_lower(b437.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b437" + ], + "range": { + "start": 38583, + "end": 38640 + } + }, + { + "id": "effect_513", + "effect_id": "effect@38665:38714", + "bound_var": "r439", + "source_text": "ctx.insert_t51_approx(b416.clone(), b438.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b416", + "b438" + ], + "range": { + "start": 38665, + "end": 38714 + } + }, + { + "id": "effect_514", + "effect_id": "effect@38728:38765", + "bound_var": null, + "source_text": "ctx.set_to_extract(445, r439.clone())", + "semantic_text": "to_extract(445) = r439", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r439" + ], + "range": { + "start": 38728, + "end": 38765 + } + }, + { + "id": "effect_515", + "effect_id": "effect@38790:38836", + "bound_var": "b440", + "source_text": "ctx.insert_t51_add(b279.clone(), b416.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b279", + "b416" + ], + "range": { + "start": 38790, + "end": 38836 + } + }, + { + "id": "effect_516", + "effect_id": "effect@38861:38907", + "bound_var": "b441", + "source_text": "ctx.insert_t51_add(b417.clone(), b279.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b279", + "b417" + ], + "range": { + "start": 38861, + "end": 38907 + } + }, + { + "id": "effect_517", + "effect_id": "effect@38932:38989", + "bound_var": "b442", + "source_text": "ctx.insert_t51_lower(b441.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b441" + ], + "range": { + "start": 38932, + "end": 38989 + } + }, + { + "id": "effect_518", + "effect_id": "effect@39014:39063", + "bound_var": "r443", + "source_text": "ctx.insert_t51_approx(b440.clone(), b442.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b440", + "b442" + ], + "range": { + "start": 39014, + "end": 39063 + } + }, + { + "id": "effect_519", + "effect_id": "effect@39077:39114", + "bound_var": null, + "source_text": "ctx.set_to_extract(449, r443.clone())", + "semantic_text": "to_extract(449) = r443", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r443" + ], + "range": { + "start": 39077, + "end": 39114 + } + }, + { + "id": "effect_520", + "effect_id": "effect@39139:39185", + "bound_var": "b444", + "source_text": "ctx.insert_t51_add(b420.clone(), b441.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b420", + "b441" + ], + "range": { + "start": 39139, + "end": 39185 + } + }, + { + "id": "effect_521", + "effect_id": "effect@39210:39267", + "bound_var": "b445", + "source_text": "ctx.insert_t51_lower(b444.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b444" + ], + "range": { + "start": 39210, + "end": 39267 + } + }, + { + "id": "effect_522", + "effect_id": "effect@39292:39341", + "bound_var": "r446", + "source_text": "ctx.insert_t51_approx(b440.clone(), b445.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b440", + "b445" + ], + "range": { + "start": 39292, + "end": 39341 + } + }, + { + "id": "effect_523", + "effect_id": "effect@39355:39392", + "bound_var": null, + "source_text": "ctx.set_to_extract(452, r446.clone())", + "semantic_text": "to_extract(452) = r446", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r446" + ], + "range": { + "start": 39355, + "end": 39392 + } + }, + { + "id": "effect_524", + "effect_id": "effect@39417:39463", + "bound_var": "b447", + "source_text": "ctx.insert_t51_add(b427.clone(), b279.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b279", + "b427" + ], + "range": { + "start": 39417, + "end": 39463 + } + }, + { + "id": "effect_525", + "effect_id": "effect@39488:39534", + "bound_var": "b448", + "source_text": "ctx.insert_t51_add(b417.clone(), b447.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b417", + "b447" + ], + "range": { + "start": 39488, + "end": 39534 + } + }, + { + "id": "effect_526", + "effect_id": "effect@39559:39616", + "bound_var": "b449", + "source_text": "ctx.insert_t51_lower(b448.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b448" + ], + "range": { + "start": 39559, + "end": 39616 + } + }, + { + "id": "effect_527", + "effect_id": "effect@39641:39690", + "bound_var": "r450", + "source_text": "ctx.insert_t51_approx(b440.clone(), b449.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b440", + "b449" + ], + "range": { + "start": 39641, + "end": 39690 + } + }, + { + "id": "effect_528", + "effect_id": "effect@39704:39741", + "bound_var": null, + "source_text": "ctx.set_to_extract(456, r450.clone())", + "semantic_text": "to_extract(456) = r450", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r450" + ], + "range": { + "start": 39704, + "end": 39741 + } + }, + { + "id": "effect_529", + "effect_id": "effect@39766:39812", + "bound_var": "b451", + "source_text": "ctx.insert_t51_add(b436.clone(), b279.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b279", + "b436" + ], + "range": { + "start": 39766, + "end": 39812 + } + }, + { + "id": "effect_530", + "effect_id": "effect@39837:39883", + "bound_var": "b452", + "source_text": "ctx.insert_t51_add(b417.clone(), b451.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b417", + "b451" + ], + "range": { + "start": 39837, + "end": 39883 + } + }, + { + "id": "effect_531", + "effect_id": "effect@39908:39965", + "bound_var": "b453", + "source_text": "ctx.insert_t51_lower(b452.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b452" + ], + "range": { + "start": 39908, + "end": 39965 + } + }, + { + "id": "effect_532", + "effect_id": "effect@39990:40039", + "bound_var": "r454", + "source_text": "ctx.insert_t51_approx(b440.clone(), b453.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b440", + "b453" + ], + "range": { + "start": 39990, + "end": 40039 + } + }, + { + "id": "effect_533", + "effect_id": "effect@40053:40090", + "bound_var": null, + "source_text": "ctx.set_to_extract(460, r454.clone())", + "semantic_text": "to_extract(460) = r454", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r454" + ], + "range": { + "start": 40053, + "end": 40090 + } + }, + { + "id": "effect_534", + "effect_id": "effect@40115:40160", + "bound_var": "b455", + "source_text": "ctx.insert_t51_add(b186.clone(), b10.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b10", + "b186" + ], + "range": { + "start": 40115, + "end": 40160 + } + }, + { + "id": "effect_535", + "effect_id": "effect@40185:40242", + "bound_var": "b456", + "source_text": "ctx.insert_t51_lower(b455.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b455" + ], + "range": { + "start": 40185, + "end": 40242 + } + }, + { + "id": "effect_536", + "effect_id": "effect@40267:40315", + "bound_var": "r457", + "source_text": "ctx.insert_t51_approx(b19.clone(), b456.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b19", + "b456" + ], + "range": { + "start": 40267, + "end": 40315 + } + }, + { + "id": "effect_537", + "effect_id": "effect@40329:40366", + "bound_var": null, + "source_text": "ctx.set_to_extract(463, r457.clone())", + "semantic_text": "to_extract(463) = r457", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r457" + ], + "range": { + "start": 40329, + "end": 40366 + } + }, + { + "id": "effect_538", + "effect_id": "effect@40391:40437", + "bound_var": "b458", + "source_text": "ctx.insert_t51_add(b192.clone(), b455.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b192", + "b455" + ], + "range": { + "start": 40391, + "end": 40437 + } + }, + { + "id": "effect_539", + "effect_id": "effect@40462:40519", + "bound_var": "b459", + "source_text": "ctx.insert_t51_lower(b458.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b458" + ], + "range": { + "start": 40462, + "end": 40519 + } + }, + { + "id": "effect_540", + "effect_id": "effect@40544:40592", + "bound_var": "r460", + "source_text": "ctx.insert_t51_approx(b19.clone(), b459.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b19", + "b459" + ], + "range": { + "start": 40544, + "end": 40592 + } + }, + { + "id": "effect_541", + "effect_id": "effect@40606:40643", + "bound_var": null, + "source_text": "ctx.set_to_extract(466, r460.clone())", + "semantic_text": "to_extract(466) = r460", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r460" + ], + "range": { + "start": 40606, + "end": 40643 + } + }, + { + "id": "effect_542", + "effect_id": "effect@40668:40714", + "bound_var": "b461", + "source_text": "ctx.insert_t51_add(b200.clone(), b455.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b200", + "b455" + ], + "range": { + "start": 40668, + "end": 40714 + } + }, + { + "id": "effect_543", + "effect_id": "effect@40739:40796", + "bound_var": "b462", + "source_text": "ctx.insert_t51_lower(b461.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b461" + ], + "range": { + "start": 40739, + "end": 40796 + } + }, + { + "id": "effect_544", + "effect_id": "effect@40821:40869", + "bound_var": "r463", + "source_text": "ctx.insert_t51_approx(b19.clone(), b462.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b19", + "b462" + ], + "range": { + "start": 40821, + "end": 40869 + } + }, + { + "id": "effect_545", + "effect_id": "effect@40883:40920", + "bound_var": null, + "source_text": "ctx.set_to_extract(469, r463.clone())", + "semantic_text": "to_extract(469) = r463", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r463" + ], + "range": { + "start": 40883, + "end": 40920 + } + }, + { + "id": "effect_546", + "effect_id": "effect@40945:40991", + "bound_var": "b464", + "source_text": "ctx.insert_t51_add(b209.clone(), b455.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b209", + "b455" + ], + "range": { + "start": 40945, + "end": 40991 + } + }, + { + "id": "effect_547", + "effect_id": "effect@41016:41073", + "bound_var": "b465", + "source_text": "ctx.insert_t51_lower(b464.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b464" + ], + "range": { + "start": 41016, + "end": 41073 + } + }, + { + "id": "effect_548", + "effect_id": "effect@41098:41146", + "bound_var": "r466", + "source_text": "ctx.insert_t51_approx(b19.clone(), b465.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b19", + "b465" + ], + "range": { + "start": 41098, + "end": 41146 + } + }, + { + "id": "effect_549", + "effect_id": "effect@41160:41197", + "bound_var": null, + "source_text": "ctx.set_to_extract(472, r466.clone())", + "semantic_text": "to_extract(472) = r466", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r466" + ], + "range": { + "start": 41160, + "end": 41197 + } + }, + { + "id": "effect_550", + "effect_id": "effect@41222:41278", + "bound_var": "b467", + "source_text": "ctx.insert_t51_lower(b25.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b25" + ], + "range": { + "start": 41222, + "end": 41278 + } + }, + { + "id": "effect_551", + "effect_id": "effect@41303:41351", + "bound_var": "r468", + "source_text": "ctx.insert_t51_approx(b20.clone(), b467.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b20", + "b467" + ], + "range": { + "start": 41303, + "end": 41351 + } + }, + { + "id": "effect_552", + "effect_id": "effect@41365:41402", + "bound_var": null, + "source_text": "ctx.set_to_extract(474, r468.clone())", + "semantic_text": "to_extract(474) = r468", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r468" + ], + "range": { + "start": 41365, + "end": 41402 + } + }, + { + "id": "effect_553", + "effect_id": "effect@41427:41483", + "bound_var": "b469", + "source_text": "ctx.insert_t51_lower(b43.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b43" + ], + "range": { + "start": 41427, + "end": 41483 + } + }, + { + "id": "effect_554", + "effect_id": "effect@41508:41556", + "bound_var": "r470", + "source_text": "ctx.insert_t51_approx(b38.clone(), b469.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b38", + "b469" + ], + "range": { + "start": 41508, + "end": 41556 + } + }, + { + "id": "effect_555", + "effect_id": "effect@41570:41607", + "bound_var": null, + "source_text": "ctx.set_to_extract(476, r470.clone())", + "semantic_text": "to_extract(476) = r470", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r470" + ], + "range": { + "start": 41570, + "end": 41607 + } + }, + { + "id": "effect_556", + "effect_id": "effect@41632:41686", + "bound_var": "b471", + "source_text": "ctx.insert_t51_div(slambda2.clone(), slambda1.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "slambda1", + "slambda2" + ], + "range": { + "start": 41632, + "end": 41686 + } + }, + { + "id": "effect_557", + "effect_id": "effect@41711:41756", + "bound_var": "b472", + "source_text": "ctx.insert_t51_mul(b49.clone(), b471.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b471", + "b49" + ], + "range": { + "start": 41711, + "end": 41756 + } + }, + { + "id": "effect_558", + "effect_id": "effect@41781:41826", + "bound_var": "b473", + "source_text": "ctx.insert_t51_add(b87.clone(), b472.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b472", + "b87" + ], + "range": { + "start": 41781, + "end": 41826 + } + }, + { + "id": "effect_559", + "effect_id": "effect@41851:41901", + "bound_var": "b474", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b473.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b473", + "slambda1" + ], + "range": { + "start": 41851, + "end": 41901 + } + }, + { + "id": "effect_560", + "effect_id": "effect@41926:41983", + "bound_var": "b475", + "source_text": "ctx.insert_t51_lower(b474.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b474" + ], + "range": { + "start": 41926, + "end": 41983 + } + }, + { + "id": "effect_561", + "effect_id": "effect@42008:42056", + "bound_var": "r476", + "source_text": "ctx.insert_t51_approx(b16.clone(), b475.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b16", + "b475" + ], + "range": { + "start": 42008, + "end": 42056 + } + }, + { + "id": "effect_562", + "effect_id": "effect@42070:42107", + "bound_var": null, + "source_text": "ctx.set_to_extract(482, r476.clone())", + "semantic_text": "to_extract(482) = r476", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r476" + ], + "range": { + "start": 42070, + "end": 42107 + } + }, + { + "id": "effect_563", + "effect_id": "effect@42132:42188", + "bound_var": "b477", + "source_text": "ctx.insert_t51_lower(b17.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b17" + ], + "range": { + "start": 42132, + "end": 42188 + } + }, + { + "id": "effect_564", + "effect_id": "effect@42213:42261", + "bound_var": "r478", + "source_text": "ctx.insert_t51_approx(b17.clone(), b477.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b17", + "b477" + ], + "range": { + "start": 42213, + "end": 42261 + } + }, + { + "id": "effect_565", + "effect_id": "effect@42275:42312", + "bound_var": null, + "source_text": "ctx.set_to_extract(484, r478.clone())", + "semantic_text": "to_extract(484) = r478", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r478" + ], + "range": { + "start": 42275, + "end": 42312 + } + }, + { + "id": "effect_566", + "effect_id": "effect@42337:42381", + "bound_var": "b479", + "source_text": "ctx.insert_t51_mul(b49.clone(), b59.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b49", + "b59" + ], + "range": { + "start": 42337, + "end": 42381 + } + }, + { + "id": "effect_567", + "effect_id": "effect@42406:42455", + "bound_var": "b480", + "source_text": "ctx.insert_t51_div(b56.clone(), slambda1.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b56", + "slambda1" + ], + "range": { + "start": 42406, + "end": 42455 + } + }, + { + "id": "effect_568", + "effect_id": "effect@42480:42526", + "bound_var": "b481", + "source_text": "ctx.insert_t51_add(b479.clone(), b480.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b479", + "b480" + ], + "range": { + "start": 42480, + "end": 42526 + } + }, + { + "id": "effect_569", + "effect_id": "effect@42551:42601", + "bound_var": "b482", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b481.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b481", + "slambda1" + ], + "range": { + "start": 42551, + "end": 42601 + } + }, + { + "id": "effect_570", + "effect_id": "effect@42626:42683", + "bound_var": "b483", + "source_text": "ctx.insert_t51_lower(b482.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b482" + ], + "range": { + "start": 42626, + "end": 42683 + } + }, + { + "id": "effect_571", + "effect_id": "effect@42708:42756", + "bound_var": "r484", + "source_text": "ctx.insert_t51_approx(b62.clone(), b483.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b483", + "b62" + ], + "range": { + "start": 42708, + "end": 42756 + } + }, + { + "id": "effect_572", + "effect_id": "effect@42770:42807", + "bound_var": null, + "source_text": "ctx.set_to_extract(490, r484.clone())", + "semantic_text": "to_extract(490) = r484", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r484" + ], + "range": { + "start": 42770, + "end": 42807 + } + }, + { + "id": "effect_573", + "effect_id": "effect@42832:42888", + "bound_var": "b485", + "source_text": "ctx.insert_t51_lower(b29.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b29" + ], + "range": { + "start": 42832, + "end": 42888 + } + }, + { + "id": "effect_574", + "effect_id": "effect@42913:42961", + "bound_var": "r486", + "source_text": "ctx.insert_t51_approx(b29.clone(), b485.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b29", + "b485" + ], + "range": { + "start": 42913, + "end": 42961 + } + }, + { + "id": "effect_575", + "effect_id": "effect@42975:43012", + "bound_var": null, + "source_text": "ctx.set_to_extract(492, r486.clone())", + "semantic_text": "to_extract(492) = r486", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r486" + ], + "range": { + "start": 42975, + "end": 43012 + } + }, + { + "id": "effect_576", + "effect_id": "effect@43037:43093", + "bound_var": "b487", + "source_text": "ctx.insert_t51_lower(b32.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b32" + ], + "range": { + "start": 43037, + "end": 43093 + } + }, + { + "id": "effect_577", + "effect_id": "effect@43118:43166", + "bound_var": "r488", + "source_text": "ctx.insert_t51_approx(b32.clone(), b487.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b32", + "b487" + ], + "range": { + "start": 43118, + "end": 43166 + } + }, + { + "id": "effect_578", + "effect_id": "effect@43180:43217", + "bound_var": null, + "source_text": "ctx.set_to_extract(494, r488.clone())", + "semantic_text": "to_extract(494) = r488", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r488" + ], + "range": { + "start": 43180, + "end": 43217 + } + }, + { + "id": "effect_579", + "effect_id": "effect@43242:43298", + "bound_var": "b489", + "source_text": "ctx.insert_t51_lower(b34.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b34" + ], + "range": { + "start": 43242, + "end": 43298 + } + }, + { + "id": "effect_580", + "effect_id": "effect@43323:43371", + "bound_var": "r490", + "source_text": "ctx.insert_t51_approx(b34.clone(), b489.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b34", + "b489" + ], + "range": { + "start": 43323, + "end": 43371 + } + }, + { + "id": "effect_581", + "effect_id": "effect@43385:43422", + "bound_var": null, + "source_text": "ctx.set_to_extract(496, r490.clone())", + "semantic_text": "to_extract(496) = r490", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r490" + ], + "range": { + "start": 43385, + "end": 43422 + } + }, + { + "id": "effect_582", + "effect_id": "effect@43447:43503", + "bound_var": "b491", + "source_text": "ctx.insert_t51_lower(b35.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b35" + ], + "range": { + "start": 43447, + "end": 43503 + } + }, + { + "id": "effect_583", + "effect_id": "effect@43528:43576", + "bound_var": "r492", + "source_text": "ctx.insert_t51_approx(b35.clone(), b491.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b35", + "b491" + ], + "range": { + "start": 43528, + "end": 43576 + } + }, + { + "id": "effect_584", + "effect_id": "effect@43590:43627", + "bound_var": null, + "source_text": "ctx.set_to_extract(498, r492.clone())", + "semantic_text": "to_extract(498) = r492", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r492" + ], + "range": { + "start": 43590, + "end": 43627 + } + }, + { + "id": "effect_585", + "effect_id": "effect@43652:43708", + "bound_var": "b493", + "source_text": "ctx.insert_t51_lower(b23.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b23" + ], + "range": { + "start": 43652, + "end": 43708 + } + }, + { + "id": "effect_586", + "effect_id": "effect@43733:43781", + "bound_var": "r494", + "source_text": "ctx.insert_t51_approx(b18.clone(), b493.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b18", + "b493" + ], + "range": { + "start": 43733, + "end": 43781 + } + }, + { + "id": "effect_587", + "effect_id": "effect@43795:43832", + "bound_var": null, + "source_text": "ctx.set_to_extract(500, r494.clone())", + "semantic_text": "to_extract(500) = r494", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r494" + ], + "range": { + "start": 43795, + "end": 43832 + } + }, + { + "id": "effect_588", + "effect_id": "effect@43857:43913", + "bound_var": "b495", + "source_text": "ctx.insert_t51_lower(b40.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b40" + ], + "range": { + "start": 43857, + "end": 43913 + } + }, + { + "id": "effect_589", + "effect_id": "effect@43938:43986", + "bound_var": "r496", + "source_text": "ctx.insert_t51_approx(b40.clone(), b495.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b40", + "b495" + ], + "range": { + "start": 43938, + "end": 43986 + } + }, + { + "id": "effect_590", + "effect_id": "effect@44000:44037", + "bound_var": null, + "source_text": "ctx.set_to_extract(502, r496.clone())", + "semantic_text": "to_extract(502) = r496", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r496" + ], + "range": { + "start": 44000, + "end": 44037 + } + }, + { + "id": "effect_591", + "effect_id": "effect@44062:44118", + "bound_var": "b497", + "source_text": "ctx.insert_t51_lower(b42.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b42" + ], + "range": { + "start": 44062, + "end": 44118 + } + }, + { + "id": "effect_592", + "effect_id": "effect@44143:44191", + "bound_var": "r498", + "source_text": "ctx.insert_t51_approx(b42.clone(), b497.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b42", + "b497" + ], + "range": { + "start": 44143, + "end": 44191 + } + }, + { + "id": "effect_593", + "effect_id": "effect@44205:44242", + "bound_var": null, + "source_text": "ctx.set_to_extract(504, r498.clone())", + "semantic_text": "to_extract(504) = r498", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r498" + ], + "range": { + "start": 44205, + "end": 44242 + } + }, + { + "id": "effect_594", + "effect_id": "effect@44267:44324", + "bound_var": "b499", + "source_text": "ctx.insert_t51_lower(b263.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b263" + ], + "range": { + "start": 44267, + "end": 44324 + } + }, + { + "id": "effect_595", + "effect_id": "effect@44349:44398", + "bound_var": "r500", + "source_text": "ctx.insert_t51_approx(b263.clone(), b499.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b263", + "b499" + ], + "range": { + "start": 44349, + "end": 44398 + } + }, + { + "id": "effect_596", + "effect_id": "effect@44412:44449", + "bound_var": null, + "source_text": "ctx.set_to_extract(506, r500.clone())", + "semantic_text": "to_extract(506) = r500", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r500" + ], + "range": { + "start": 44412, + "end": 44449 + } + }, + { + "id": "effect_597", + "effect_id": "effect@44474:44531", + "bound_var": "b501", + "source_text": "ctx.insert_t51_lower(b280.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b280" + ], + "range": { + "start": 44474, + "end": 44531 + } + }, + { + "id": "effect_598", + "effect_id": "effect@44556:44605", + "bound_var": "r502", + "source_text": "ctx.insert_t51_approx(b280.clone(), b501.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b280", + "b501" + ], + "range": { + "start": 44556, + "end": 44605 + } + }, + { + "id": "effect_599", + "effect_id": "effect@44619:44656", + "bound_var": null, + "source_text": "ctx.set_to_extract(508, r502.clone())", + "semantic_text": "to_extract(508) = r502", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r502" + ], + "range": { + "start": 44619, + "end": 44656 + } + }, + { + "id": "effect_600", + "effect_id": "effect@44681:44731", + "bound_var": "b503", + "source_text": "ctx.insert_t51_div(b306.clone(), slambda1.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b306", + "slambda1" + ], + "range": { + "start": 44681, + "end": 44731 + } + }, + { + "id": "effect_601", + "effect_id": "effect@44756:44801", + "bound_var": "b504", + "source_text": "ctx.insert_t51_mul(b98.clone(), b503.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b503", + "b98" + ], + "range": { + "start": 44756, + "end": 44801 + } + }, + { + "id": "effect_602", + "effect_id": "effect@44826:44871", + "bound_var": "b505", + "source_text": "ctx.insert_t51_add(b87.clone(), b504.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b504", + "b87" + ], + "range": { + "start": 44826, + "end": 44871 + } + }, + { + "id": "effect_603", + "effect_id": "effect@44896:44942", + "bound_var": "b506", + "source_text": "ctx.insert_t51_sub(b505.clone(), b471.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b471", + "b505" + ], + "range": { + "start": 44896, + "end": 44942 + } + }, + { + "id": "effect_604", + "effect_id": "effect@44967:45017", + "bound_var": "b507", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b506.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b506", + "slambda1" + ], + "range": { + "start": 44967, + "end": 45017 + } + }, + { + "id": "effect_605", + "effect_id": "effect@45042:45099", + "bound_var": "b508", + "source_text": "ctx.insert_t51_lower(b507.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b507" + ], + "range": { + "start": 45042, + "end": 45099 + } + }, + { + "id": "effect_606", + "effect_id": "effect@45124:45173", + "bound_var": "r509", + "source_text": "ctx.insert_t51_approx(b308.clone(), b508.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b308", + "b508" + ], + "range": { + "start": 45124, + "end": 45173 + } + }, + { + "id": "effect_607", + "effect_id": "effect@45187:45224", + "bound_var": null, + "source_text": "ctx.set_to_extract(515, r509.clone())", + "semantic_text": "to_extract(515) = r509", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r509" + ], + "range": { + "start": 45187, + "end": 45224 + } + }, + { + "id": "effect_608", + "effect_id": "effect@45249:45300", + "bound_var": "b510", + "source_text": "ctx.insert_t51_div(sphi2.clone(), slambda1.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "slambda1", + "sphi2" + ], + "range": { + "start": 45249, + "end": 45300 + } + }, + { + "id": "effect_609", + "effect_id": "effect@45325:45371", + "bound_var": "b511", + "source_text": "ctx.insert_t51_add(b471.clone(), b510.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b471", + "b510" + ], + "range": { + "start": 45325, + "end": 45371 + } + }, + { + "id": "effect_610", + "effect_id": "effect@45396:45442", + "bound_var": "b512", + "source_text": "ctx.insert_t51_sub(b505.clone(), b511.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b505", + "b511" + ], + "range": { + "start": 45396, + "end": 45442 + } + }, + { + "id": "effect_611", + "effect_id": "effect@45467:45517", + "bound_var": "b513", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b512.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b512", + "slambda1" + ], + "range": { + "start": 45467, + "end": 45517 + } + }, + { + "id": "effect_612", + "effect_id": "effect@45542:45599", + "bound_var": "b514", + "source_text": "ctx.insert_t51_lower(b513.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b513" + ], + "range": { + "start": 45542, + "end": 45599 + } + }, + { + "id": "effect_613", + "effect_id": "effect@45624:45673", + "bound_var": "r515", + "source_text": "ctx.insert_t51_approx(b316.clone(), b514.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b316", + "b514" + ], + "range": { + "start": 45624, + "end": 45673 + } + }, + { + "id": "effect_614", + "effect_id": "effect@45687:45724", + "bound_var": null, + "source_text": "ctx.set_to_extract(521, r515.clone())", + "semantic_text": "to_extract(521) = r515", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r515" + ], + "range": { + "start": 45687, + "end": 45724 + } + }, + { + "id": "effect_615", + "effect_id": "effect@45749:45781", + "bound_var": "b516", + "source_text": "ctx.insert_t51_sin(b321.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b321" + ], + "range": { + "start": 45749, + "end": 45781 + } + }, + { + "id": "effect_616", + "effect_id": "effect@45806:45863", + "bound_var": "b517", + "source_text": "ctx.insert_t51_lower(b516.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b516" + ], + "range": { + "start": 45806, + "end": 45863 + } + }, + { + "id": "effect_617", + "effect_id": "effect@45888:45937", + "bound_var": "r518", + "source_text": "ctx.insert_t51_approx(b324.clone(), b517.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b324", + "b517" + ], + "range": { + "start": 45888, + "end": 45937 + } + }, + { + "id": "effect_618", + "effect_id": "effect@45951:45988", + "bound_var": null, + "source_text": "ctx.set_to_extract(524, r518.clone())", + "semantic_text": "to_extract(524) = r518", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r518" + ], + "range": { + "start": 45951, + "end": 45988 + } + }, + { + "id": "effect_619", + "effect_id": "effect@46013:46059", + "bound_var": "b519", + "source_text": "ctx.insert_t51_add(b504.clone(), b510.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b504", + "b510" + ], + "range": { + "start": 46013, + "end": 46059 + } + }, + { + "id": "effect_620", + "effect_id": "effect@46084:46129", + "bound_var": "b520", + "source_text": "ctx.insert_t51_add(b87.clone(), b519.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b519", + "b87" + ], + "range": { + "start": 46084, + "end": 46129 + } + }, + { + "id": "effect_621", + "effect_id": "effect@46154:46200", + "bound_var": "b521", + "source_text": "ctx.insert_t51_sub(b520.clone(), b471.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b471", + "b520" + ], + "range": { + "start": 46154, + "end": 46200 + } + }, + { + "id": "effect_622", + "effect_id": "effect@46225:46275", + "bound_var": "b522", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b521.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b521", + "slambda1" + ], + "range": { + "start": 46225, + "end": 46275 + } + }, + { + "id": "effect_623", + "effect_id": "effect@46300:46357", + "bound_var": "b523", + "source_text": "ctx.insert_t51_lower(b522.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b522" + ], + "range": { + "start": 46300, + "end": 46357 + } + }, + { + "id": "effect_624", + "effect_id": "effect@46382:46431", + "bound_var": "r524", + "source_text": "ctx.insert_t51_approx(b349.clone(), b523.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b349", + "b523" + ], + "range": { + "start": 46382, + "end": 46431 + } + }, + { + "id": "effect_625", + "effect_id": "effect@46445:46482", + "bound_var": null, + "source_text": "ctx.set_to_extract(530, r524.clone())", + "semantic_text": "to_extract(530) = r524", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r524" + ], + "range": { + "start": 46445, + "end": 46482 + } + }, + { + "id": "effect_626", + "effect_id": "effect@46507:46539", + "bound_var": "b525", + "source_text": "ctx.insert_t51_sin(b355.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b355" + ], + "range": { + "start": 46507, + "end": 46539 + } + }, + { + "id": "effect_627", + "effect_id": "effect@46564:46621", + "bound_var": "b526", + "source_text": "ctx.insert_t51_lower(b525.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b525" + ], + "range": { + "start": 46564, + "end": 46621 + } + }, + { + "id": "effect_628", + "effect_id": "effect@46646:46695", + "bound_var": "r527", + "source_text": "ctx.insert_t51_approx(b358.clone(), b526.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b358", + "b526" + ], + "range": { + "start": 46646, + "end": 46695 + } + }, + { + "id": "effect_629", + "effect_id": "effect@46709:46746", + "bound_var": null, + "source_text": "ctx.set_to_extract(533, r527.clone())", + "semantic_text": "to_extract(533) = r527", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r527" + ], + "range": { + "start": 46709, + "end": 46746 + } + }, + { + "id": "effect_630", + "effect_id": "effect@46771:46817", + "bound_var": "b528", + "source_text": "ctx.insert_t51_add(b516.clone(), b525.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b516", + "b525" + ], + "range": { + "start": 46771, + "end": 46817 + } + }, + { + "id": "effect_631", + "effect_id": "effect@46842:46899", + "bound_var": "b529", + "source_text": "ctx.insert_t51_lower(b528.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b528" + ], + "range": { + "start": 46842, + "end": 46899 + } + }, + { + "id": "effect_632", + "effect_id": "effect@46924:46973", + "bound_var": "r530", + "source_text": "ctx.insert_t51_approx(b383.clone(), b529.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b383", + "b529" + ], + "range": { + "start": 46924, + "end": 46973 + } + }, + { + "id": "effect_633", + "effect_id": "effect@46987:47024", + "bound_var": null, + "source_text": "ctx.set_to_extract(536, r530.clone())", + "semantic_text": "to_extract(536) = r530", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r530" + ], + "range": { + "start": 46987, + "end": 47024 + } + }, + { + "id": "effect_634", + "effect_id": "effect@47049:47094", + "bound_var": "b531", + "source_text": "ctx.insert_t51_mul(b98.clone(), b528.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b528", + "b98" + ], + "range": { + "start": 47049, + "end": 47094 + } + }, + { + "id": "effect_635", + "effect_id": "effect@47119:47176", + "bound_var": "b532", + "source_text": "ctx.insert_t51_lower(b531.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b531" + ], + "range": { + "start": 47119, + "end": 47176 + } + }, + { + "id": "effect_636", + "effect_id": "effect@47201:47250", + "bound_var": "r533", + "source_text": "ctx.insert_t51_approx(b416.clone(), b532.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b416", + "b532" + ], + "range": { + "start": 47201, + "end": 47250 + } + }, + { + "id": "effect_637", + "effect_id": "effect@47264:47301", + "bound_var": null, + "source_text": "ctx.set_to_extract(539, r533.clone())", + "semantic_text": "to_extract(539) = r533", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r533" + ], + "range": { + "start": 47264, + "end": 47301 + } + }, + { + "id": "effect_638", + "effect_id": "effect@47326:47372", + "bound_var": "b534", + "source_text": "ctx.insert_t51_add(b531.clone(), b279.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b279", + "b531" + ], + "range": { + "start": 47326, + "end": 47372 + } + }, + { + "id": "effect_639", + "effect_id": "effect@47397:47454", + "bound_var": "b535", + "source_text": "ctx.insert_t51_lower(b534.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b534" + ], + "range": { + "start": 47397, + "end": 47454 + } + }, + { + "id": "effect_640", + "effect_id": "effect@47479:47528", + "bound_var": "r536", + "source_text": "ctx.insert_t51_approx(b440.clone(), b535.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b440", + "b535" + ], + "range": { + "start": 47479, + "end": 47528 + } + }, + { + "id": "effect_641", + "effect_id": "effect@47542:47579", + "bound_var": null, + "source_text": "ctx.set_to_extract(542, r536.clone())", + "semantic_text": "to_extract(542) = r536", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r536" + ], + "range": { + "start": 47542, + "end": 47579 + } + }, + { + "id": "effect_642", + "effect_id": "effect@47604:47660", + "bound_var": "b537", + "source_text": "ctx.insert_t51_lower(b24.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b24" + ], + "range": { + "start": 47604, + "end": 47660 + } + }, + { + "id": "effect_643", + "effect_id": "effect@47685:47733", + "bound_var": "r538", + "source_text": "ctx.insert_t51_approx(b19.clone(), b537.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b19", + "b537" + ], + "range": { + "start": 47685, + "end": 47733 + } + }, + { + "id": "effect_644", + "effect_id": "effect@47747:47784", + "bound_var": null, + "source_text": "ctx.set_to_extract(544, r538.clone())", + "semantic_text": "to_extract(544) = r538", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r538" + ], + "range": { + "start": 47747, + "end": 47784 + } + }, + { + "id": "effect_645", + "effect_id": "effect@47809:47854", + "bound_var": "b539", + "source_text": "ctx.insert_t51_sub(b471.clone(), b87.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b471", + "b87" + ], + "range": { + "start": 47809, + "end": 47854 + } + }, + { + "id": "effect_646", + "effect_id": "effect@47879:47929", + "bound_var": "b540", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b539.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b539", + "slambda1" + ], + "range": { + "start": 47879, + "end": 47929 + } + }, + { + "id": "effect_647", + "effect_id": "effect@47954:47999", + "bound_var": "b541", + "source_text": "ctx.insert_t51_mul(b49.clone(), b540.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b49", + "b540" + ], + "range": { + "start": 47954, + "end": 47999 + } + }, + { + "id": "effect_648", + "effect_id": "effect@48024:48081", + "bound_var": "b542", + "source_text": "ctx.insert_t51_lower(b541.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b541" + ], + "range": { + "start": 48024, + "end": 48081 + } + }, + { + "id": "effect_649", + "effect_id": "effect@48106:48154", + "bound_var": "r543", + "source_text": "ctx.insert_t51_approx(b16.clone(), b542.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b16", + "b542" + ], + "range": { + "start": 48106, + "end": 48154 + } + }, + { + "id": "effect_650", + "effect_id": "effect@48168:48205", + "bound_var": null, + "source_text": "ctx.set_to_extract(549, r543.clone())", + "semantic_text": "to_extract(549) = r543", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r543" + ], + "range": { + "start": 48168, + "end": 48205 + } + }, + { + "id": "effect_651", + "effect_id": "effect@48230:48279", + "bound_var": "b544", + "source_text": "ctx.insert_t51_mul(b49.clone(), slambda1.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b49", + "slambda1" + ], + "range": { + "start": 48230, + "end": 48279 + } + }, + { + "id": "effect_652", + "effect_id": "effect@48304:48354", + "bound_var": "b545", + "source_text": "ctx.insert_t51_add(slambda2.clone(), b544.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b544", + "slambda2" + ], + "range": { + "start": 48304, + "end": 48354 + } + }, + { + "id": "effect_653", + "effect_id": "effect@48379:48411", + "bound_var": "b546", + "source_text": "ctx.insert_t51_neg(b545.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b545" + ], + "range": { + "start": 48379, + "end": 48411 + } + }, + { + "id": "effect_654", + "effect_id": "effect@48436:48468", + "bound_var": "b547", + "source_text": "ctx.insert_t51_cos(b546.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b546" + ], + "range": { + "start": 48436, + "end": 48468 + } + }, + { + "id": "effect_655", + "effect_id": "effect@48493:48550", + "bound_var": "b548", + "source_text": "ctx.insert_t51_lower(b547.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b547" + ], + "range": { + "start": 48493, + "end": 48550 + } + }, + { + "id": "effect_656", + "effect_id": "effect@48575:48623", + "bound_var": "r549", + "source_text": "ctx.insert_t51_approx(b17.clone(), b548.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b17", + "b548" + ], + "range": { + "start": 48575, + "end": 48623 + } + }, + { + "id": "effect_657", + "effect_id": "effect@48637:48674", + "bound_var": null, + "source_text": "ctx.set_to_extract(555, r549.clone())", + "semantic_text": "to_extract(555) = r549", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r549" + ], + "range": { + "start": 48637, + "end": 48674 + } + }, + { + "id": "effect_658", + "effect_id": "effect@48699:48744", + "bound_var": "b550", + "source_text": "ctx.insert_t51_mul(b49.clone(), b480.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b480", + "b49" + ], + "range": { + "start": 48699, + "end": 48744 + } + }, + { + "id": "effect_659", + "effect_id": "effect@48769:48814", + "bound_var": "b551", + "source_text": "ctx.insert_t51_add(b59.clone(), b550.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b550", + "b59" + ], + "range": { + "start": 48769, + "end": 48814 + } + }, + { + "id": "effect_660", + "effect_id": "effect@48839:48889", + "bound_var": "b552", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b551.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b551", + "slambda1" + ], + "range": { + "start": 48839, + "end": 48889 + } + }, + { + "id": "effect_661", + "effect_id": "effect@48914:48959", + "bound_var": "b553", + "source_text": "ctx.insert_t51_mul(b49.clone(), b552.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b49", + "b552" + ], + "range": { + "start": 48914, + "end": 48959 + } + }, + { + "id": "effect_662", + "effect_id": "effect@48984:49041", + "bound_var": "b554", + "source_text": "ctx.insert_t51_lower(b553.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b553" + ], + "range": { + "start": 48984, + "end": 49041 + } + }, + { + "id": "effect_663", + "effect_id": "effect@49066:49114", + "bound_var": "r555", + "source_text": "ctx.insert_t51_approx(b62.clone(), b554.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b554", + "b62" + ], + "range": { + "start": 49066, + "end": 49114 + } + }, + { + "id": "effect_664", + "effect_id": "effect@49128:49165", + "bound_var": null, + "source_text": "ctx.set_to_extract(561, r555.clone())", + "semantic_text": "to_extract(561) = r555", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r555" + ], + "range": { + "start": 49128, + "end": 49165 + } + }, + { + "id": "effect_665", + "effect_id": "effect@49190:49235", + "bound_var": "b556", + "source_text": "ctx.insert_t51_mul(b12.clone(), b547.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b12", + "b547" + ], + "range": { + "start": 49190, + "end": 49235 + } + }, + { + "id": "effect_666", + "effect_id": "effect@49260:49305", + "bound_var": "b557", + "source_text": "ctx.insert_t51_mul(b11.clone(), b556.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b11", + "b556" + ], + "range": { + "start": 49260, + "end": 49305 + } + }, + { + "id": "effect_667", + "effect_id": "effect@49330:49387", + "bound_var": "b558", + "source_text": "ctx.insert_t51_lower(b557.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b557" + ], + "range": { + "start": 49330, + "end": 49387 + } + }, + { + "id": "effect_668", + "effect_id": "effect@49412:49460", + "bound_var": "r559", + "source_text": "ctx.insert_t51_approx(b18.clone(), b558.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b18", + "b558" + ], + "range": { + "start": 49412, + "end": 49460 + } + }, + { + "id": "effect_669", + "effect_id": "effect@49474:49511", + "bound_var": null, + "source_text": "ctx.set_to_extract(565, r559.clone())", + "semantic_text": "to_extract(565) = r559", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r559" + ], + "range": { + "start": 49474, + "end": 49511 + } + }, + { + "id": "effect_670", + "effect_id": "effect@49536:49582", + "bound_var": "b560", + "source_text": "ctx.insert_t51_add(b547.clone(), b262.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b262", + "b547" + ], + "range": { + "start": 49536, + "end": 49582 + } + }, + { + "id": "effect_671", + "effect_id": "effect@49607:49664", + "bound_var": "b561", + "source_text": "ctx.insert_t51_lower(b560.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b560" + ], + "range": { + "start": 49607, + "end": 49664 + } + }, + { + "id": "effect_672", + "effect_id": "effect@49689:49738", + "bound_var": "r562", + "source_text": "ctx.insert_t51_approx(b263.clone(), b561.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b263", + "b561" + ], + "range": { + "start": 49689, + "end": 49738 + } + }, + { + "id": "effect_673", + "effect_id": "effect@49752:49789", + "bound_var": null, + "source_text": "ctx.set_to_extract(568, r562.clone())", + "semantic_text": "to_extract(568) = r562", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r562" + ], + "range": { + "start": 49752, + "end": 49789 + } + }, + { + "id": "effect_674", + "effect_id": "effect@49814:49860", + "bound_var": "b563", + "source_text": "ctx.insert_t51_add(b279.clone(), b556.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b279", + "b556" + ], + "range": { + "start": 49814, + "end": 49860 + } + }, + { + "id": "effect_675", + "effect_id": "effect@49885:49942", + "bound_var": "b564", + "source_text": "ctx.insert_t51_lower(b563.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b563" + ], + "range": { + "start": 49885, + "end": 49942 + } + }, + { + "id": "effect_676", + "effect_id": "effect@49967:50016", + "bound_var": "r565", + "source_text": "ctx.insert_t51_approx(b280.clone(), b564.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b280", + "b564" + ], + "range": { + "start": 49967, + "end": 50016 + } + }, + { + "id": "effect_677", + "effect_id": "effect@50030:50067", + "bound_var": null, + "source_text": "ctx.set_to_extract(571, r565.clone())", + "semantic_text": "to_extract(571) = r565", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r565" + ], + "range": { + "start": 50030, + "end": 50067 + } + }, + { + "id": "effect_678", + "effect_id": "effect@50092:50142", + "bound_var": "b566", + "source_text": "ctx.insert_t51_div(b309.clone(), slambda1.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b309", + "slambda1" + ], + "range": { + "start": 50092, + "end": 50142 + } + }, + { + "id": "effect_679", + "effect_id": "effect@50167:50212", + "bound_var": "b567", + "source_text": "ctx.insert_t51_mul(b49.clone(), b566.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b49", + "b566" + ], + "range": { + "start": 50167, + "end": 50212 + } + }, + { + "id": "effect_680", + "effect_id": "effect@50237:50282", + "bound_var": "b568", + "source_text": "ctx.insert_t51_sub(b567.clone(), b87.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b567", + "b87" + ], + "range": { + "start": 50237, + "end": 50282 + } + }, + { + "id": "effect_681", + "effect_id": "effect@50307:50357", + "bound_var": "b569", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b568.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b568", + "slambda1" + ], + "range": { + "start": 50307, + "end": 50357 + } + }, + { + "id": "effect_682", + "effect_id": "effect@50382:50427", + "bound_var": "b570", + "source_text": "ctx.insert_t51_mul(b49.clone(), b569.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b49", + "b569" + ], + "range": { + "start": 50382, + "end": 50427 + } + }, + { + "id": "effect_683", + "effect_id": "effect@50452:50509", + "bound_var": "b571", + "source_text": "ctx.insert_t51_lower(b570.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b570" + ], + "range": { + "start": 50452, + "end": 50509 + } + }, + { + "id": "effect_684", + "effect_id": "effect@50534:50583", + "bound_var": "r572", + "source_text": "ctx.insert_t51_approx(b308.clone(), b571.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b308", + "b571" + ], + "range": { + "start": 50534, + "end": 50583 + } + }, + { + "id": "effect_685", + "effect_id": "effect@50597:50634", + "bound_var": null, + "source_text": "ctx.set_to_extract(578, r572.clone())", + "semantic_text": "to_extract(578) = r572", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r572" + ], + "range": { + "start": 50597, + "end": 50634 + } + }, + { + "id": "effect_686", + "effect_id": "effect@50659:50709", + "bound_var": "b573", + "source_text": "ctx.insert_t51_div(b318.clone(), slambda1.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b318", + "slambda1" + ], + "range": { + "start": 50659, + "end": 50709 + } + }, + { + "id": "effect_687", + "effect_id": "effect@50734:50779", + "bound_var": "b574", + "source_text": "ctx.insert_t51_mul(b49.clone(), b573.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b49", + "b573" + ], + "range": { + "start": 50734, + "end": 50779 + } + }, + { + "id": "effect_688", + "effect_id": "effect@50804:50849", + "bound_var": "b575", + "source_text": "ctx.insert_t51_sub(b574.clone(), b87.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b574", + "b87" + ], + "range": { + "start": 50804, + "end": 50849 + } + }, + { + "id": "effect_689", + "effect_id": "effect@50874:50924", + "bound_var": "b576", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b575.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b575", + "slambda1" + ], + "range": { + "start": 50874, + "end": 50924 + } + }, + { + "id": "effect_690", + "effect_id": "effect@50949:50994", + "bound_var": "b577", + "source_text": "ctx.insert_t51_mul(b49.clone(), b576.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b49", + "b576" + ], + "range": { + "start": 50949, + "end": 50994 + } + }, + { + "id": "effect_691", + "effect_id": "effect@51019:51076", + "bound_var": "b578", + "source_text": "ctx.insert_t51_lower(b577.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b577" + ], + "range": { + "start": 51019, + "end": 51076 + } + }, + { + "id": "effect_692", + "effect_id": "effect@51101:51150", + "bound_var": "r579", + "source_text": "ctx.insert_t51_approx(b316.clone(), b578.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b316", + "b578" + ], + "range": { + "start": 51101, + "end": 51150 + } + }, + { + "id": "effect_693", + "effect_id": "effect@51164:51201", + "bound_var": null, + "source_text": "ctx.set_to_extract(585, r579.clone())", + "semantic_text": "to_extract(585) = r579", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r579" + ], + "range": { + "start": 51164, + "end": 51201 + } + }, + { + "id": "effect_694", + "effect_id": "effect@51226:51273", + "bound_var": "b580", + "source_text": "ctx.insert_t51_add(sphi2.clone(), b544.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b544", + "sphi2" + ], + "range": { + "start": 51226, + "end": 51273 + } + }, + { + "id": "effect_695", + "effect_id": "effect@51298:51348", + "bound_var": "b581", + "source_text": "ctx.insert_t51_add(slambda2.clone(), b580.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b580", + "slambda2" + ], + "range": { + "start": 51298, + "end": 51348 + } + }, + { + "id": "effect_696", + "effect_id": "effect@51373:51419", + "bound_var": "b582", + "source_text": "ctx.insert_t51_sub(b307.clone(), b581.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b307", + "b581" + ], + "range": { + "start": 51373, + "end": 51419 + } + }, + { + "id": "effect_697", + "effect_id": "effect@51444:51476", + "bound_var": "b583", + "source_text": "ctx.insert_t51_sin(b582.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b582" + ], + "range": { + "start": 51444, + "end": 51476 + } + }, + { + "id": "effect_698", + "effect_id": "effect@51501:51558", + "bound_var": "b584", + "source_text": "ctx.insert_t51_lower(b583.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b583" + ], + "range": { + "start": 51501, + "end": 51558 + } + }, + { + "id": "effect_699", + "effect_id": "effect@51583:51632", + "bound_var": "r585", + "source_text": "ctx.insert_t51_approx(b324.clone(), b584.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b324", + "b584" + ], + "range": { + "start": 51583, + "end": 51632 + } + }, + { + "id": "effect_700", + "effect_id": "effect@51646:51683", + "bound_var": null, + "source_text": "ctx.set_to_extract(591, r585.clone())", + "semantic_text": "to_extract(591) = r585", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r585" + ], + "range": { + "start": 51646, + "end": 51683 + } + }, + { + "id": "effect_701", + "effect_id": "effect@51708:51758", + "bound_var": "b586", + "source_text": "ctx.insert_t51_div(b351.clone(), slambda1.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b351", + "slambda1" + ], + "range": { + "start": 51708, + "end": 51758 + } + }, + { + "id": "effect_702", + "effect_id": "effect@51783:51828", + "bound_var": "b587", + "source_text": "ctx.insert_t51_mul(b49.clone(), b586.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b49", + "b586" + ], + "range": { + "start": 51783, + "end": 51828 + } + }, + { + "id": "effect_703", + "effect_id": "effect@51853:51898", + "bound_var": "b588", + "source_text": "ctx.insert_t51_sub(b587.clone(), b87.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b587", + "b87" + ], + "range": { + "start": 51853, + "end": 51898 + } + }, + { + "id": "effect_704", + "effect_id": "effect@51923:51973", + "bound_var": "b589", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b588.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b588", + "slambda1" + ], + "range": { + "start": 51923, + "end": 51973 + } + }, + { + "id": "effect_705", + "effect_id": "effect@51998:52043", + "bound_var": "b590", + "source_text": "ctx.insert_t51_mul(b49.clone(), b589.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b49", + "b589" + ], + "range": { + "start": 51998, + "end": 52043 + } + }, + { + "id": "effect_706", + "effect_id": "effect@52068:52125", + "bound_var": "b591", + "source_text": "ctx.insert_t51_lower(b590.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b590" + ], + "range": { + "start": 52068, + "end": 52125 + } + }, + { + "id": "effect_707", + "effect_id": "effect@52150:52199", + "bound_var": "r592", + "source_text": "ctx.insert_t51_approx(b349.clone(), b591.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b349", + "b591" + ], + "range": { + "start": 52150, + "end": 52199 + } + }, + { + "id": "effect_708", + "effect_id": "effect@52213:52250", + "bound_var": null, + "source_text": "ctx.set_to_extract(598, r592.clone())", + "semantic_text": "to_extract(598) = r592", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r592" + ], + "range": { + "start": 52213, + "end": 52250 + } + }, + { + "id": "effect_709", + "effect_id": "effect@52275:52321", + "bound_var": "b593", + "source_text": "ctx.insert_t51_sub(b350.clone(), b545.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b350", + "b545" + ], + "range": { + "start": 52275, + "end": 52321 + } + }, + { + "id": "effect_710", + "effect_id": "effect@52346:52378", + "bound_var": "b594", + "source_text": "ctx.insert_t51_sin(b593.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b593" + ], + "range": { + "start": 52346, + "end": 52378 + } + }, + { + "id": "effect_711", + "effect_id": "effect@52403:52460", + "bound_var": "b595", + "source_text": "ctx.insert_t51_lower(b594.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b594" + ], + "range": { + "start": 52403, + "end": 52460 + } + }, + { + "id": "effect_712", + "effect_id": "effect@52485:52534", + "bound_var": "r596", + "source_text": "ctx.insert_t51_approx(b358.clone(), b595.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b358", + "b595" + ], + "range": { + "start": 52485, + "end": 52534 + } + }, + { + "id": "effect_713", + "effect_id": "effect@52548:52585", + "bound_var": null, + "source_text": "ctx.set_to_extract(602, r596.clone())", + "semantic_text": "to_extract(602) = r596", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r596" + ], + "range": { + "start": 52548, + "end": 52585 + } + }, + { + "id": "effect_714", + "effect_id": "effect@52610:52656", + "bound_var": "b597", + "source_text": "ctx.insert_t51_add(b583.clone(), b594.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b583", + "b594" + ], + "range": { + "start": 52610, + "end": 52656 + } + }, + { + "id": "effect_715", + "effect_id": "effect@52681:52738", + "bound_var": "b598", + "source_text": "ctx.insert_t51_lower(b597.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b597" + ], + "range": { + "start": 52681, + "end": 52738 + } + }, + { + "id": "effect_716", + "effect_id": "effect@52763:52812", + "bound_var": "r599", + "source_text": "ctx.insert_t51_approx(b383.clone(), b598.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b383", + "b598" + ], + "range": { + "start": 52763, + "end": 52812 + } + }, + { + "id": "effect_717", + "effect_id": "effect@52826:52863", + "bound_var": null, + "source_text": "ctx.set_to_extract(605, r599.clone())", + "semantic_text": "to_extract(605) = r599", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r599" + ], + "range": { + "start": 52826, + "end": 52863 + } + }, + { + "id": "effect_718", + "effect_id": "effect@52888:52933", + "bound_var": "b600", + "source_text": "ctx.insert_t51_mul(b98.clone(), b597.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b597", + "b98" + ], + "range": { + "start": 52888, + "end": 52933 + } + }, + { + "id": "effect_719", + "effect_id": "effect@52958:53015", + "bound_var": "b601", + "source_text": "ctx.insert_t51_lower(b600.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b600" + ], + "range": { + "start": 52958, + "end": 53015 + } + }, + { + "id": "effect_720", + "effect_id": "effect@53040:53089", + "bound_var": "r602", + "source_text": "ctx.insert_t51_approx(b416.clone(), b601.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b416", + "b601" + ], + "range": { + "start": 53040, + "end": 53089 + } + }, + { + "id": "effect_721", + "effect_id": "effect@53103:53140", + "bound_var": null, + "source_text": "ctx.set_to_extract(608, r602.clone())", + "semantic_text": "to_extract(608) = r602", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r602" + ], + "range": { + "start": 53103, + "end": 53140 + } + }, + { + "id": "effect_722", + "effect_id": "effect@53165:53211", + "bound_var": "b603", + "source_text": "ctx.insert_t51_add(b600.clone(), b279.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b279", + "b600" + ], + "range": { + "start": 53165, + "end": 53211 + } + }, + { + "id": "effect_723", + "effect_id": "effect@53236:53293", + "bound_var": "b604", + "source_text": "ctx.insert_t51_lower(b603.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b603" + ], + "range": { + "start": 53236, + "end": 53293 + } + }, + { + "id": "effect_724", + "effect_id": "effect@53318:53367", + "bound_var": "r605", + "source_text": "ctx.insert_t51_approx(b440.clone(), b604.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b440", + "b604" + ], + "range": { + "start": 53318, + "end": 53367 + } + }, + { + "id": "effect_725", + "effect_id": "effect@53381:53418", + "bound_var": null, + "source_text": "ctx.set_to_extract(611, r605.clone())", + "semantic_text": "to_extract(611) = r605", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r605" + ], + "range": { + "start": 53381, + "end": 53418 + } + }, + { + "id": "effect_726", + "effect_id": "effect@53443:53488", + "bound_var": "b606", + "source_text": "ctx.insert_t51_add(b557.clone(), b10.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b10", + "b557" + ], + "range": { + "start": 53443, + "end": 53488 + } + }, + { + "id": "effect_727", + "effect_id": "effect@53513:53570", + "bound_var": "b607", + "source_text": "ctx.insert_t51_lower(b606.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b606" + ], + "range": { + "start": 53513, + "end": 53570 + } + }, + { + "id": "effect_728", + "effect_id": "effect@53595:53643", + "bound_var": "r608", + "source_text": "ctx.insert_t51_approx(b19.clone(), b607.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b19", + "b607" + ], + "range": { + "start": 53595, + "end": 53643 + } + }, + { + "id": "effect_729", + "effect_id": "effect@53657:53694", + "bound_var": null, + "source_text": "ctx.set_to_extract(614, r608.clone())", + "semantic_text": "to_extract(614) = r608", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r608" + ], + "range": { + "start": 53657, + "end": 53694 + } + }, + { + "id": "effect_730", + "effect_id": "effect@53719:53752", + "bound_var": "b609", + "source_text": "ctx.insert_t51_acos(b606.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b606" + ], + "range": { + "start": 53719, + "end": 53752 + } + }, + { + "id": "effect_731", + "effect_id": "effect@53777:53834", + "bound_var": "b610", + "source_text": "ctx.insert_t51_lower(b609.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b609" + ], + "range": { + "start": 53777, + "end": 53834 + } + }, + { + "id": "effect_732", + "effect_id": "effect@53859:53907", + "bound_var": "r611", + "source_text": "ctx.insert_t51_approx(b20.clone(), b610.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b20", + "b610" + ], + "range": { + "start": 53859, + "end": 53907 + } + }, + { + "id": "effect_733", + "effect_id": "effect@53921:53958", + "bound_var": null, + "source_text": "ctx.set_to_extract(617, r611.clone())", + "semantic_text": "to_extract(617) = r611", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r611" + ], + "range": { + "start": 53921, + "end": 53958 + } + }, + { + "id": "effect_734", + "effect_id": "effect@53983:54027", + "bound_var": "b612", + "source_text": "ctx.insert_t51_mul(sR.clone(), b609.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b609", + "sR" + ], + "range": { + "start": 53983, + "end": 54027 + } + }, + { + "id": "effect_735", + "effect_id": "effect@54052:54109", + "bound_var": "b613", + "source_text": "ctx.insert_t51_lower(b612.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b612" + ], + "range": { + "start": 54052, + "end": 54109 + } + }, + { + "id": "effect_736", + "effect_id": "effect@54134:54182", + "bound_var": "r614", + "source_text": "ctx.insert_t51_approx(b21.clone(), b613.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b21", + "b613" + ], + "range": { + "start": 54134, + "end": 54182 + } + }, + { + "id": "effect_737", + "effect_id": "effect@54196:54233", + "bound_var": null, + "source_text": "ctx.set_to_extract(620, r614.clone())", + "semantic_text": "to_extract(620) = r614", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r614" + ], + "range": { + "start": 54196, + "end": 54233 + } + }, + { + "id": "effect_738", + "effect_id": "effect@54258:54319", + "bound_var": "b615", + "source_text": "ctx.insert_t51_lower(slambda2.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "slambda2" + ], + "range": { + "start": 54258, + "end": 54319 + } + }, + { + "id": "effect_739", + "effect_id": "effect@54344:54397", + "bound_var": "r616", + "source_text": "ctx.insert_t51_approx(slambda2.clone(), b615.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b615", + "slambda2" + ], + "range": { + "start": 54344, + "end": 54397 + } + }, + { + "id": "effect_740", + "effect_id": "effect@54411:54448", + "bound_var": null, + "source_text": "ctx.set_to_extract(622, r616.clone())", + "semantic_text": "to_extract(622) = r616", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r616" + ], + "range": { + "start": 54411, + "end": 54448 + } + }, + { + "id": "effect_741", + "effect_id": "effect@54473:54522", + "bound_var": "b617", + "source_text": "ctx.insert_t51_add(slambda1.clone(), b50.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b50", + "slambda1" + ], + "range": { + "start": 54473, + "end": 54522 + } + }, + { + "id": "effect_742", + "effect_id": "effect@54547:54604", + "bound_var": "b618", + "source_text": "ctx.insert_t51_lower(b617.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b617" + ], + "range": { + "start": 54547, + "end": 54604 + } + }, + { + "id": "effect_743", + "effect_id": "effect@54629:54677", + "bound_var": "r619", + "source_text": "ctx.insert_t51_approx(b16.clone(), b618.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b16", + "b618" + ], + "range": { + "start": 54629, + "end": 54677 + } + }, + { + "id": "effect_744", + "effect_id": "effect@54691:54728", + "bound_var": null, + "source_text": "ctx.set_to_extract(625, r619.clone())", + "semantic_text": "to_extract(625) = r619", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r619" + ], + "range": { + "start": 54691, + "end": 54728 + } + }, + { + "id": "effect_745", + "effect_id": "effect@54753:54802", + "bound_var": "b620", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b32.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b32", + "slambda2" + ], + "range": { + "start": 54753, + "end": 54802 + } + }, + { + "id": "effect_746", + "effect_id": "effect@54827:54872", + "bound_var": "b621", + "source_text": "ctx.insert_t51_add(b29.clone(), b620.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b29", + "b620" + ], + "range": { + "start": 54827, + "end": 54872 + } + }, + { + "id": "effect_747", + "effect_id": "effect@54897:54954", + "bound_var": "b622", + "source_text": "ctx.insert_t51_lower(b621.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b621" + ], + "range": { + "start": 54897, + "end": 54954 + } + }, + { + "id": "effect_748", + "effect_id": "effect@54979:55027", + "bound_var": "r623", + "source_text": "ctx.insert_t51_approx(b17.clone(), b622.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b17", + "b622" + ], + "range": { + "start": 54979, + "end": 55027 + } + }, + { + "id": "effect_749", + "effect_id": "effect@55041:55078", + "bound_var": null, + "source_text": "ctx.set_to_extract(629, r623.clone())", + "semantic_text": "to_extract(629) = r623", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r623" + ], + "range": { + "start": 55041, + "end": 55078 + } + }, + { + "id": "effect_750", + "effect_id": "effect@55103:55152", + "bound_var": "b624", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b29.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b29", + "slambda2" + ], + "range": { + "start": 55103, + "end": 55152 + } + }, + { + "id": "effect_751", + "effect_id": "effect@55177:55222", + "bound_var": "b625", + "source_text": "ctx.insert_t51_mul(b65.clone(), b624.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b624", + "b65" + ], + "range": { + "start": 55177, + "end": 55222 + } + }, + { + "id": "effect_752", + "effect_id": "effect@55247:55291", + "bound_var": "b626", + "source_text": "ctx.insert_t51_mul(b49.clone(), b32.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b32", + "b49" + ], + "range": { + "start": 55247, + "end": 55291 + } + }, + { + "id": "effect_753", + "effect_id": "effect@55316:55362", + "bound_var": "b627", + "source_text": "ctx.insert_t51_sub(b625.clone(), b626.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b625", + "b626" + ], + "range": { + "start": 55316, + "end": 55362 + } + }, + { + "id": "effect_754", + "effect_id": "effect@55387:55437", + "bound_var": "b628", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b627.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b627", + "slambda2" + ], + "range": { + "start": 55387, + "end": 55437 + } + }, + { + "id": "effect_755", + "effect_id": "effect@55462:55507", + "bound_var": "b629", + "source_text": "ctx.insert_t51_add(b29.clone(), b628.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b29", + "b628" + ], + "range": { + "start": 55462, + "end": 55507 + } + }, + { + "id": "effect_756", + "effect_id": "effect@55532:55589", + "bound_var": "b630", + "source_text": "ctx.insert_t51_lower(b629.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b629" + ], + "range": { + "start": 55532, + "end": 55589 + } + }, + { + "id": "effect_757", + "effect_id": "effect@55614:55662", + "bound_var": "r631", + "source_text": "ctx.insert_t51_approx(b17.clone(), b630.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b17", + "b630" + ], + "range": { + "start": 55614, + "end": 55662 + } + }, + { + "id": "effect_758", + "effect_id": "effect@55676:55713", + "bound_var": null, + "source_text": "ctx.set_to_extract(637, r631.clone())", + "semantic_text": "to_extract(637) = r631", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r631" + ], + "range": { + "start": 55676, + "end": 55713 + } + }, + { + "id": "effect_759", + "effect_id": "effect@55738:55782", + "bound_var": "b632", + "source_text": "ctx.insert_t51_mul(b65.clone(), b29.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b29", + "b65" + ], + "range": { + "start": 55738, + "end": 55782 + } + }, + { + "id": "effect_760", + "effect_id": "effect@55807:55853", + "bound_var": "b633", + "source_text": "ctx.insert_t51_mul(b113.clone(), b620.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b620" + ], + "range": { + "start": 55807, + "end": 55853 + } + }, + { + "id": "effect_761", + "effect_id": "effect@55878:55924", + "bound_var": "b634", + "source_text": "ctx.insert_t51_add(b632.clone(), b633.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b632", + "b633" + ], + "range": { + "start": 55878, + "end": 55924 + } + }, + { + "id": "effect_762", + "effect_id": "effect@55949:55999", + "bound_var": "b635", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b634.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b634", + "slambda2" + ], + "range": { + "start": 55949, + "end": 55999 + } + }, + { + "id": "effect_763", + "effect_id": "effect@56024:56070", + "bound_var": "b636", + "source_text": "ctx.insert_t51_sub(b635.clone(), b626.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b626", + "b635" + ], + "range": { + "start": 56024, + "end": 56070 + } + }, + { + "id": "effect_764", + "effect_id": "effect@56095:56145", + "bound_var": "b637", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b636.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b636", + "slambda2" + ], + "range": { + "start": 56095, + "end": 56145 + } + }, + { + "id": "effect_765", + "effect_id": "effect@56170:56215", + "bound_var": "b638", + "source_text": "ctx.insert_t51_add(b29.clone(), b637.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b29", + "b637" + ], + "range": { + "start": 56170, + "end": 56215 + } + }, + { + "id": "effect_766", + "effect_id": "effect@56240:56297", + "bound_var": "b639", + "source_text": "ctx.insert_t51_lower(b638.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b638" + ], + "range": { + "start": 56240, + "end": 56297 + } + }, + { + "id": "effect_767", + "effect_id": "effect@56322:56370", + "bound_var": "r640", + "source_text": "ctx.insert_t51_approx(b17.clone(), b639.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b17", + "b639" + ], + "range": { + "start": 56322, + "end": 56370 + } + }, + { + "id": "effect_768", + "effect_id": "effect@56384:56421", + "bound_var": null, + "source_text": "ctx.set_to_extract(646, r640.clone())", + "semantic_text": "to_extract(646) = r640", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r640" + ], + "range": { + "start": 56384, + "end": 56421 + } + }, + { + "id": "effect_769", + "effect_id": "effect@56446:56495", + "bound_var": "b641", + "source_text": "ctx.insert_t51_pow(slambda2.clone(), b90.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b90", + "slambda2" + ], + "range": { + "start": 56446, + "end": 56495 + } + }, + { + "id": "effect_770", + "effect_id": "effect@56520:56565", + "bound_var": "b642", + "source_text": "ctx.insert_t51_mul(b65.clone(), b641.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b641", + "b65" + ], + "range": { + "start": 56520, + "end": 56565 + } + }, + { + "id": "effect_771", + "effect_id": "effect@56590:56635", + "bound_var": "b643", + "source_text": "ctx.insert_t51_add(b87.clone(), b642.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b642", + "b87" + ], + "range": { + "start": 56590, + "end": 56635 + } + }, + { + "id": "effect_772", + "effect_id": "effect@56660:56717", + "bound_var": "b644", + "source_text": "ctx.insert_t51_lower(b643.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b643" + ], + "range": { + "start": 56660, + "end": 56717 + } + }, + { + "id": "effect_773", + "effect_id": "effect@56742:56790", + "bound_var": "r645", + "source_text": "ctx.insert_t51_approx(b56.clone(), b644.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b56", + "b644" + ], + "range": { + "start": 56742, + "end": 56790 + } + }, + { + "id": "effect_774", + "effect_id": "effect@56804:56841", + "bound_var": null, + "source_text": "ctx.set_to_extract(651, r645.clone())", + "semantic_text": "to_extract(651) = r645", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r645" + ], + "range": { + "start": 56804, + "end": 56841 + } + }, + { + "id": "effect_775", + "effect_id": "effect@56866:56911", + "bound_var": "b646", + "source_text": "ctx.insert_t51_mul(b96.clone(), b641.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b641", + "b96" + ], + "range": { + "start": 56866, + "end": 56911 + } + }, + { + "id": "effect_776", + "effect_id": "effect@56936:56981", + "bound_var": "b647", + "source_text": "ctx.insert_t51_sub(b646.clone(), b98.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b646", + "b98" + ], + "range": { + "start": 56936, + "end": 56981 + } + }, + { + "id": "effect_777", + "effect_id": "effect@57006:57052", + "bound_var": "b648", + "source_text": "ctx.insert_t51_mul(b641.clone(), b647.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b641", + "b647" + ], + "range": { + "start": 57006, + "end": 57052 + } + }, + { + "id": "effect_778", + "effect_id": "effect@57077:57122", + "bound_var": "b649", + "source_text": "ctx.insert_t51_add(b87.clone(), b648.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b648", + "b87" + ], + "range": { + "start": 57077, + "end": 57122 + } + }, + { + "id": "effect_779", + "effect_id": "effect@57147:57204", + "bound_var": "b650", + "source_text": "ctx.insert_t51_lower(b649.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b649" + ], + "range": { + "start": 57147, + "end": 57204 + } + }, + { + "id": "effect_780", + "effect_id": "effect@57229:57277", + "bound_var": "r651", + "source_text": "ctx.insert_t51_approx(b56.clone(), b650.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b56", + "b650" + ], + "range": { + "start": 57229, + "end": 57277 + } + }, + { + "id": "effect_781", + "effect_id": "effect@57291:57328", + "bound_var": null, + "source_text": "ctx.set_to_extract(657, r651.clone())", + "semantic_text": "to_extract(657) = r651", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r651" + ], + "range": { + "start": 57291, + "end": 57328 + } + }, + { + "id": "effect_782", + "effect_id": "effect@57353:57399", + "bound_var": "b652", + "source_text": "ctx.insert_t51_mul(b104.clone(), b641.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b104", + "b641" + ], + "range": { + "start": 57353, + "end": 57399 + } + }, + { + "id": "effect_783", + "effect_id": "effect@57424:57469", + "bound_var": "b653", + "source_text": "ctx.insert_t51_add(b96.clone(), b652.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b652", + "b96" + ], + "range": { + "start": 57424, + "end": 57469 + } + }, + { + "id": "effect_784", + "effect_id": "effect@57494:57540", + "bound_var": "b654", + "source_text": "ctx.insert_t51_mul(b641.clone(), b653.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b641", + "b653" + ], + "range": { + "start": 57494, + "end": 57540 + } + }, + { + "id": "effect_785", + "effect_id": "effect@57565:57610", + "bound_var": "b655", + "source_text": "ctx.insert_t51_sub(b654.clone(), b98.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b654", + "b98" + ], + "range": { + "start": 57565, + "end": 57610 + } + }, + { + "id": "effect_786", + "effect_id": "effect@57635:57681", + "bound_var": "b656", + "source_text": "ctx.insert_t51_mul(b641.clone(), b655.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b641", + "b655" + ], + "range": { + "start": 57635, + "end": 57681 + } + }, + { + "id": "effect_787", + "effect_id": "effect@57706:57751", + "bound_var": "b657", + "source_text": "ctx.insert_t51_add(b87.clone(), b656.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b656", + "b87" + ], + "range": { + "start": 57706, + "end": 57751 + } + }, + { + "id": "effect_788", + "effect_id": "effect@57776:57833", + "bound_var": "b658", + "source_text": "ctx.insert_t51_lower(b657.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b657" + ], + "range": { + "start": 57776, + "end": 57833 + } + }, + { + "id": "effect_789", + "effect_id": "effect@57858:57906", + "bound_var": "r659", + "source_text": "ctx.insert_t51_approx(b56.clone(), b658.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b56", + "b658" + ], + "range": { + "start": 57858, + "end": 57906 + } + }, + { + "id": "effect_790", + "effect_id": "effect@57920:57957", + "bound_var": null, + "source_text": "ctx.set_to_extract(665, r659.clone())", + "semantic_text": "to_extract(665) = r659", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r659" + ], + "range": { + "start": 57920, + "end": 57957 + } + }, + { + "id": "effect_791", + "effect_id": "effect@57982:58027", + "bound_var": "b660", + "source_text": "ctx.insert_t51_mul(b74.clone(), b641.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b641", + "b74" + ], + "range": { + "start": 57982, + "end": 58027 + } + }, + { + "id": "effect_792", + "effect_id": "effect@58052:58097", + "bound_var": "b661", + "source_text": "ctx.insert_t51_sub(b660.clone(), b87.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b660", + "b87" + ], + "range": { + "start": 58052, + "end": 58097 + } + }, + { + "id": "effect_793", + "effect_id": "effect@58122:58172", + "bound_var": "b662", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b661.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b661", + "slambda2" + ], + "range": { + "start": 58122, + "end": 58172 + } + }, + { + "id": "effect_794", + "effect_id": "effect@58197:58254", + "bound_var": "b663", + "source_text": "ctx.insert_t51_lower(b662.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b662" + ], + "range": { + "start": 58197, + "end": 58254 + } + }, + { + "id": "effect_795", + "effect_id": "effect@58279:58327", + "bound_var": "r664", + "source_text": "ctx.insert_t51_approx(b59.clone(), b663.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b59", + "b663" + ], + "range": { + "start": 58279, + "end": 58327 + } + }, + { + "id": "effect_796", + "effect_id": "effect@58341:58378", + "bound_var": null, + "source_text": "ctx.set_to_extract(670, r664.clone())", + "semantic_text": "to_extract(670) = r664", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r664" + ], + "range": { + "start": 58341, + "end": 58378 + } + }, + { + "id": "effect_797", + "effect_id": "effect@58403:58442", + "bound_var": "b665", + "source_text": "ctx.insert_t51_num(\"-1/120\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 58403, + "end": 58442 + } + }, + { + "id": "effect_798", + "effect_id": "effect@58467:58513", + "bound_var": "b666", + "source_text": "ctx.insert_t51_mul(b665.clone(), b641.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b641", + "b665" + ], + "range": { + "start": 58467, + "end": 58513 + } + }, + { + "id": "effect_799", + "effect_id": "effect@58538:58583", + "bound_var": "b667", + "source_text": "ctx.insert_t51_add(b74.clone(), b666.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b666", + "b74" + ], + "range": { + "start": 58538, + "end": 58583 + } + }, + { + "id": "effect_800", + "effect_id": "effect@58608:58654", + "bound_var": "b668", + "source_text": "ctx.insert_t51_mul(b641.clone(), b667.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b641", + "b667" + ], + "range": { + "start": 58608, + "end": 58654 + } + }, + { + "id": "effect_801", + "effect_id": "effect@58679:58724", + "bound_var": "b669", + "source_text": "ctx.insert_t51_sub(b668.clone(), b87.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b668", + "b87" + ], + "range": { + "start": 58679, + "end": 58724 + } + }, + { + "id": "effect_802", + "effect_id": "effect@58749:58799", + "bound_var": "b670", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b669.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b669", + "slambda2" + ], + "range": { + "start": 58749, + "end": 58799 + } + }, + { + "id": "effect_803", + "effect_id": "effect@58824:58881", + "bound_var": "b671", + "source_text": "ctx.insert_t51_lower(b670.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b670" + ], + "range": { + "start": 58824, + "end": 58881 + } + }, + { + "id": "effect_804", + "effect_id": "effect@58906:58954", + "bound_var": "r672", + "source_text": "ctx.insert_t51_approx(b59.clone(), b671.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b59", + "b671" + ], + "range": { + "start": 58906, + "end": 58954 + } + }, + { + "id": "effect_805", + "effect_id": "effect@58968:59005", + "bound_var": null, + "source_text": "ctx.set_to_extract(678, r672.clone())", + "semantic_text": "to_extract(678) = r672", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r672" + ], + "range": { + "start": 58968, + "end": 59005 + } + }, + { + "id": "effect_806", + "effect_id": "effect@59030:59069", + "bound_var": "b673", + "source_text": "ctx.insert_t51_num(\"1/5040\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 59030, + "end": 59069 + } + }, + { + "id": "effect_807", + "effect_id": "effect@59094:59140", + "bound_var": "b674", + "source_text": "ctx.insert_t51_mul(b673.clone(), b641.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b641", + "b673" + ], + "range": { + "start": 59094, + "end": 59140 + } + }, + { + "id": "effect_808", + "effect_id": "effect@59165:59211", + "bound_var": "b675", + "source_text": "ctx.insert_t51_sub(b674.clone(), b119.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b119", + "b674" + ], + "range": { + "start": 59165, + "end": 59211 + } + }, + { + "id": "effect_809", + "effect_id": "effect@59236:59282", + "bound_var": "b676", + "source_text": "ctx.insert_t51_mul(b641.clone(), b675.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b641", + "b675" + ], + "range": { + "start": 59236, + "end": 59282 + } + }, + { + "id": "effect_810", + "effect_id": "effect@59307:59352", + "bound_var": "b677", + "source_text": "ctx.insert_t51_add(b74.clone(), b676.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b676", + "b74" + ], + "range": { + "start": 59307, + "end": 59352 + } + }, + { + "id": "effect_811", + "effect_id": "effect@59377:59423", + "bound_var": "b678", + "source_text": "ctx.insert_t51_mul(b641.clone(), b677.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b641", + "b677" + ], + "range": { + "start": 59377, + "end": 59423 + } + }, + { + "id": "effect_812", + "effect_id": "effect@59448:59493", + "bound_var": "b679", + "source_text": "ctx.insert_t51_sub(b678.clone(), b87.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b678", + "b87" + ], + "range": { + "start": 59448, + "end": 59493 + } + }, + { + "id": "effect_813", + "effect_id": "effect@59518:59568", + "bound_var": "b680", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b679.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b679", + "slambda2" + ], + "range": { + "start": 59518, + "end": 59568 + } + }, + { + "id": "effect_814", + "effect_id": "effect@59593:59650", + "bound_var": "b681", + "source_text": "ctx.insert_t51_lower(b680.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b680" + ], + "range": { + "start": 59593, + "end": 59650 + } + }, + { + "id": "effect_815", + "effect_id": "effect@59675:59723", + "bound_var": "r682", + "source_text": "ctx.insert_t51_approx(b59.clone(), b681.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b59", + "b681" + ], + "range": { + "start": 59675, + "end": 59723 + } + }, + { + "id": "effect_816", + "effect_id": "effect@59737:59774", + "bound_var": null, + "source_text": "ctx.set_to_extract(688, r682.clone())", + "semantic_text": "to_extract(688) = r682", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r682" + ], + "range": { + "start": 59737, + "end": 59774 + } + }, + { + "id": "effect_817", + "effect_id": "effect@59799:59853", + "bound_var": "b683", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), slambda2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "slambda1", + "slambda2" + ], + "range": { + "start": 59799, + "end": 59853 + } + }, + { + "id": "effect_818", + "effect_id": "effect@59878:59923", + "bound_var": "b684", + "source_text": "ctx.insert_t51_mul(b49.clone(), b683.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b49", + "b683" + ], + "range": { + "start": 59878, + "end": 59923 + } + }, + { + "id": "effect_819", + "effect_id": "effect@59948:60005", + "bound_var": "b685", + "source_text": "ctx.insert_t51_lower(b684.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b684" + ], + "range": { + "start": 59948, + "end": 60005 + } + }, + { + "id": "effect_820", + "effect_id": "effect@60030:60078", + "bound_var": "r686", + "source_text": "ctx.insert_t51_approx(b60.clone(), b685.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b60", + "b685" + ], + "range": { + "start": 60030, + "end": 60078 + } + }, + { + "id": "effect_821", + "effect_id": "effect@60092:60129", + "bound_var": null, + "source_text": "ctx.set_to_extract(692, r686.clone())", + "semantic_text": "to_extract(692) = r686", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r686" + ], + "range": { + "start": 60092, + "end": 60129 + } + }, + { + "id": "effect_822", + "effect_id": "effect@60154:60204", + "bound_var": "b687", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b641.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b641", + "slambda1" + ], + "range": { + "start": 60154, + "end": 60204 + } + }, + { + "id": "effect_823", + "effect_id": "effect@60229:60274", + "bound_var": "b688", + "source_text": "ctx.insert_t51_mul(b74.clone(), b687.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b687", + "b74" + ], + "range": { + "start": 60229, + "end": 60274 + } + }, + { + "id": "effect_824", + "effect_id": "effect@60299:60345", + "bound_var": "b689", + "source_text": "ctx.insert_t51_add(b544.clone(), b688.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b544", + "b688" + ], + "range": { + "start": 60299, + "end": 60345 + } + }, + { + "id": "effect_825", + "effect_id": "effect@60370:60420", + "bound_var": "b690", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b689.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b689", + "slambda2" + ], + "range": { + "start": 60370, + "end": 60420 + } + }, + { + "id": "effect_826", + "effect_id": "effect@60445:60502", + "bound_var": "b691", + "source_text": "ctx.insert_t51_lower(b690.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b690" + ], + "range": { + "start": 60445, + "end": 60502 + } + }, + { + "id": "effect_827", + "effect_id": "effect@60527:60575", + "bound_var": "r692", + "source_text": "ctx.insert_t51_approx(b60.clone(), b691.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b60", + "b691" + ], + "range": { + "start": 60527, + "end": 60575 + } + }, + { + "id": "effect_828", + "effect_id": "effect@60589:60626", + "bound_var": null, + "source_text": "ctx.set_to_extract(698, r692.clone())", + "semantic_text": "to_extract(698) = r692", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r692" + ], + "range": { + "start": 60589, + "end": 60626 + } + }, + { + "id": "effect_829", + "effect_id": "effect@60651:60697", + "bound_var": "b693", + "source_text": "ctx.insert_t51_mul(b665.clone(), b687.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b665", + "b687" + ], + "range": { + "start": 60651, + "end": 60697 + } + }, + { + "id": "effect_830", + "effect_id": "effect@60722:60771", + "bound_var": "b694", + "source_text": "ctx.insert_t51_mul(b74.clone(), slambda1.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b74", + "slambda1" + ], + "range": { + "start": 60722, + "end": 60771 + } + }, + { + "id": "effect_831", + "effect_id": "effect@60796:60842", + "bound_var": "b695", + "source_text": "ctx.insert_t51_add(b693.clone(), b694.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b693", + "b694" + ], + "range": { + "start": 60796, + "end": 60842 + } + }, + { + "id": "effect_832", + "effect_id": "effect@60867:60913", + "bound_var": "b696", + "source_text": "ctx.insert_t51_mul(b641.clone(), b695.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b641", + "b695" + ], + "range": { + "start": 60867, + "end": 60913 + } + }, + { + "id": "effect_833", + "effect_id": "effect@60938:60984", + "bound_var": "b697", + "source_text": "ctx.insert_t51_add(b544.clone(), b696.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b544", + "b696" + ], + "range": { + "start": 60938, + "end": 60984 + } + }, + { + "id": "effect_834", + "effect_id": "effect@61009:61059", + "bound_var": "b698", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b697.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b697", + "slambda2" + ], + "range": { + "start": 61009, + "end": 61059 + } + }, + { + "id": "effect_835", + "effect_id": "effect@61084:61141", + "bound_var": "b699", + "source_text": "ctx.insert_t51_lower(b698.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b698" + ], + "range": { + "start": 61084, + "end": 61141 + } + }, + { + "id": "effect_836", + "effect_id": "effect@61166:61214", + "bound_var": "r700", + "source_text": "ctx.insert_t51_approx(b60.clone(), b699.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b60", + "b699" + ], + "range": { + "start": 61166, + "end": 61214 + } + }, + { + "id": "effect_837", + "effect_id": "effect@61228:61265", + "bound_var": null, + "source_text": "ctx.set_to_extract(706, r700.clone())", + "semantic_text": "to_extract(706) = r700", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r700" + ], + "range": { + "start": 61228, + "end": 61265 + } + }, + { + "id": "effect_838", + "effect_id": "effect@61290:61340", + "bound_var": "b701", + "source_text": "ctx.insert_t51_mul(b665.clone(), slambda1.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b665", + "slambda1" + ], + "range": { + "start": 61290, + "end": 61340 + } + }, + { + "id": "effect_839", + "effect_id": "effect@61365:61411", + "bound_var": "b702", + "source_text": "ctx.insert_t51_mul(b673.clone(), b687.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b673", + "b687" + ], + "range": { + "start": 61365, + "end": 61411 + } + }, + { + "id": "effect_840", + "effect_id": "effect@61436:61482", + "bound_var": "b703", + "source_text": "ctx.insert_t51_add(b701.clone(), b702.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b701", + "b702" + ], + "range": { + "start": 61436, + "end": 61482 + } + }, + { + "id": "effect_841", + "effect_id": "effect@61507:61553", + "bound_var": "b704", + "source_text": "ctx.insert_t51_mul(b641.clone(), b703.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b641", + "b703" + ], + "range": { + "start": 61507, + "end": 61553 + } + }, + { + "id": "effect_842", + "effect_id": "effect@61578:61624", + "bound_var": "b705", + "source_text": "ctx.insert_t51_add(b694.clone(), b704.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b694", + "b704" + ], + "range": { + "start": 61578, + "end": 61624 + } + }, + { + "id": "effect_843", + "effect_id": "effect@61649:61695", + "bound_var": "b706", + "source_text": "ctx.insert_t51_mul(b641.clone(), b705.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b641", + "b705" + ], + "range": { + "start": 61649, + "end": 61695 + } + }, + { + "id": "effect_844", + "effect_id": "effect@61720:61766", + "bound_var": "b707", + "source_text": "ctx.insert_t51_add(b544.clone(), b706.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b544", + "b706" + ], + "range": { + "start": 61720, + "end": 61766 + } + }, + { + "id": "effect_845", + "effect_id": "effect@61791:61841", + "bound_var": "b708", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b707.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b707", + "slambda2" + ], + "range": { + "start": 61791, + "end": 61841 + } + }, + { + "id": "effect_846", + "effect_id": "effect@61866:61923", + "bound_var": "b709", + "source_text": "ctx.insert_t51_lower(b708.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b708" + ], + "range": { + "start": 61866, + "end": 61923 + } + }, + { + "id": "effect_847", + "effect_id": "effect@61948:61996", + "bound_var": "r710", + "source_text": "ctx.insert_t51_approx(b60.clone(), b709.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b60", + "b709" + ], + "range": { + "start": 61948, + "end": 61996 + } + }, + { + "id": "effect_848", + "effect_id": "effect@62010:62047", + "bound_var": null, + "source_text": "ctx.set_to_extract(716, r710.clone())", + "semantic_text": "to_extract(716) = r710", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r710" + ], + "range": { + "start": 62010, + "end": 62047 + } + }, + { + "id": "effect_849", + "effect_id": "effect@62072:62129", + "bound_var": "b711", + "source_text": "ctx.insert_t51_lower(b683.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b683" + ], + "range": { + "start": 62072, + "end": 62129 + } + }, + { + "id": "effect_850", + "effect_id": "effect@62154:62202", + "bound_var": "r712", + "source_text": "ctx.insert_t51_approx(b61.clone(), b711.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b61", + "b711" + ], + "range": { + "start": 62154, + "end": 62202 + } + }, + { + "id": "effect_851", + "effect_id": "effect@62216:62253", + "bound_var": null, + "source_text": "ctx.set_to_extract(718, r712.clone())", + "semantic_text": "to_extract(718) = r712", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r712" + ], + "range": { + "start": 62216, + "end": 62253 + } + }, + { + "id": "effect_852", + "effect_id": "effect@62278:62324", + "bound_var": "b713", + "source_text": "ctx.insert_t51_mul(b113.clone(), b687.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b687" + ], + "range": { + "start": 62278, + "end": 62324 + } + }, + { + "id": "effect_853", + "effect_id": "effect@62349:62399", + "bound_var": "b714", + "source_text": "ctx.insert_t51_add(slambda1.clone(), b713.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b713", + "slambda1" + ], + "range": { + "start": 62349, + "end": 62399 + } + }, + { + "id": "effect_854", + "effect_id": "effect@62424:62474", + "bound_var": "b715", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b714.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b714", + "slambda2" + ], + "range": { + "start": 62424, + "end": 62474 + } + }, + { + "id": "effect_855", + "effect_id": "effect@62499:62556", + "bound_var": "b716", + "source_text": "ctx.insert_t51_lower(b715.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b715" + ], + "range": { + "start": 62499, + "end": 62556 + } + }, + { + "id": "effect_856", + "effect_id": "effect@62581:62629", + "bound_var": "r717", + "source_text": "ctx.insert_t51_approx(b61.clone(), b716.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b61", + "b716" + ], + "range": { + "start": 62581, + "end": 62629 + } + }, + { + "id": "effect_857", + "effect_id": "effect@62643:62680", + "bound_var": null, + "source_text": "ctx.set_to_extract(723, r717.clone())", + "semantic_text": "to_extract(723) = r717", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r717" + ], + "range": { + "start": 62643, + "end": 62680 + } + }, + { + "id": "effect_858", + "effect_id": "effect@62705:62755", + "bound_var": "b718", + "source_text": "ctx.insert_t51_mul(b113.clone(), slambda1.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "slambda1" + ], + "range": { + "start": 62705, + "end": 62755 + } + }, + { + "id": "effect_859", + "effect_id": "effect@62780:62826", + "bound_var": "b719", + "source_text": "ctx.insert_t51_mul(b119.clone(), b687.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b119", + "b687" + ], + "range": { + "start": 62780, + "end": 62826 + } + }, + { + "id": "effect_860", + "effect_id": "effect@62851:62897", + "bound_var": "b720", + "source_text": "ctx.insert_t51_add(b718.clone(), b719.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b718", + "b719" + ], + "range": { + "start": 62851, + "end": 62897 + } + }, + { + "id": "effect_861", + "effect_id": "effect@62922:62968", + "bound_var": "b721", + "source_text": "ctx.insert_t51_mul(b641.clone(), b720.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b641", + "b720" + ], + "range": { + "start": 62922, + "end": 62968 + } + }, + { + "id": "effect_862", + "effect_id": "effect@62993:63043", + "bound_var": "b722", + "source_text": "ctx.insert_t51_add(slambda1.clone(), b721.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b721", + "slambda1" + ], + "range": { + "start": 62993, + "end": 63043 + } + }, + { + "id": "effect_863", + "effect_id": "effect@63068:63118", + "bound_var": "b723", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b722.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b722", + "slambda2" + ], + "range": { + "start": 63068, + "end": 63118 + } + }, + { + "id": "effect_864", + "effect_id": "effect@63143:63200", + "bound_var": "b724", + "source_text": "ctx.insert_t51_lower(b723.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b723" + ], + "range": { + "start": 63143, + "end": 63200 + } + }, + { + "id": "effect_865", + "effect_id": "effect@63225:63273", + "bound_var": "r725", + "source_text": "ctx.insert_t51_approx(b61.clone(), b724.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b61", + "b724" + ], + "range": { + "start": 63225, + "end": 63273 + } + }, + { + "id": "effect_866", + "effect_id": "effect@63287:63324", + "bound_var": null, + "source_text": "ctx.set_to_extract(731, r725.clone())", + "semantic_text": "to_extract(731) = r725", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r725" + ], + "range": { + "start": 63287, + "end": 63324 + } + }, + { + "id": "effect_867", + "effect_id": "effect@63349:63395", + "bound_var": "b726", + "source_text": "ctx.insert_t51_mul(b127.clone(), b687.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b127", + "b687" + ], + "range": { + "start": 63349, + "end": 63395 + } + }, + { + "id": "effect_868", + "effect_id": "effect@63420:63470", + "bound_var": "b727", + "source_text": "ctx.insert_t51_mul(b119.clone(), slambda1.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b119", + "slambda1" + ], + "range": { + "start": 63420, + "end": 63470 + } + }, + { + "id": "effect_869", + "effect_id": "effect@63495:63541", + "bound_var": "b728", + "source_text": "ctx.insert_t51_add(b726.clone(), b727.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b726", + "b727" + ], + "range": { + "start": 63495, + "end": 63541 + } + }, + { + "id": "effect_870", + "effect_id": "effect@63566:63612", + "bound_var": "b729", + "source_text": "ctx.insert_t51_mul(b641.clone(), b728.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b641", + "b728" + ], + "range": { + "start": 63566, + "end": 63612 + } + }, + { + "id": "effect_871", + "effect_id": "effect@63637:63683", + "bound_var": "b730", + "source_text": "ctx.insert_t51_add(b718.clone(), b729.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b718", + "b729" + ], + "range": { + "start": 63637, + "end": 63683 + } + }, + { + "id": "effect_872", + "effect_id": "effect@63708:63754", + "bound_var": "b731", + "source_text": "ctx.insert_t51_mul(b641.clone(), b730.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b641", + "b730" + ], + "range": { + "start": 63708, + "end": 63754 + } + }, + { + "id": "effect_873", + "effect_id": "effect@63779:63829", + "bound_var": "b732", + "source_text": "ctx.insert_t51_add(slambda1.clone(), b731.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b731", + "slambda1" + ], + "range": { + "start": 63779, + "end": 63829 + } + }, + { + "id": "effect_874", + "effect_id": "effect@63854:63904", + "bound_var": "b733", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b732.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b732", + "slambda2" + ], + "range": { + "start": 63854, + "end": 63904 + } + }, + { + "id": "effect_875", + "effect_id": "effect@63929:63986", + "bound_var": "b734", + "source_text": "ctx.insert_t51_lower(b733.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b733" + ], + "range": { + "start": 63929, + "end": 63986 + } + }, + { + "id": "effect_876", + "effect_id": "effect@64011:64059", + "bound_var": "r735", + "source_text": "ctx.insert_t51_approx(b61.clone(), b734.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b61", + "b734" + ], + "range": { + "start": 64011, + "end": 64059 + } + }, + { + "id": "effect_877", + "effect_id": "effect@64073:64110", + "bound_var": null, + "source_text": "ctx.set_to_extract(741, r735.clone())", + "semantic_text": "to_extract(741) = r735", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r735" + ], + "range": { + "start": 64073, + "end": 64110 + } + }, + { + "id": "effect_878", + "effect_id": "effect@64135:64180", + "bound_var": "b736", + "source_text": "ctx.insert_t51_add(b87.clone(), b683.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b683", + "b87" + ], + "range": { + "start": 64135, + "end": 64180 + } + }, + { + "id": "effect_879", + "effect_id": "effect@64205:64262", + "bound_var": "b737", + "source_text": "ctx.insert_t51_lower(b736.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b736" + ], + "range": { + "start": 64205, + "end": 64262 + } + }, + { + "id": "effect_880", + "effect_id": "effect@64287:64335", + "bound_var": "r738", + "source_text": "ctx.insert_t51_approx(b62.clone(), b737.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b62", + "b737" + ], + "range": { + "start": 64287, + "end": 64335 + } + }, + { + "id": "effect_881", + "effect_id": "effect@64349:64386", + "bound_var": null, + "source_text": "ctx.set_to_extract(744, r738.clone())", + "semantic_text": "to_extract(744) = r738", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r738" + ], + "range": { + "start": 64349, + "end": 64386 + } + }, + { + "id": "effect_882", + "effect_id": "effect@64411:64460", + "bound_var": "b739", + "source_text": "ctx.insert_t51_mul(b65.clone(), slambda2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b65", + "slambda2" + ], + "range": { + "start": 64411, + "end": 64460 + } + }, + { + "id": "effect_883", + "effect_id": "effect@64485:64535", + "bound_var": "b740", + "source_text": "ctx.insert_t51_add(slambda1.clone(), b739.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b739", + "slambda1" + ], + "range": { + "start": 64485, + "end": 64535 + } + }, + { + "id": "effect_884", + "effect_id": "effect@64560:64610", + "bound_var": "b741", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b740.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b740", + "slambda2" + ], + "range": { + "start": 64560, + "end": 64610 + } + }, + { + "id": "effect_885", + "effect_id": "effect@64635:64680", + "bound_var": "b742", + "source_text": "ctx.insert_t51_add(b87.clone(), b741.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b741", + "b87" + ], + "range": { + "start": 64635, + "end": 64680 + } + }, + { + "id": "effect_886", + "effect_id": "effect@64705:64762", + "bound_var": "b743", + "source_text": "ctx.insert_t51_lower(b742.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b742" + ], + "range": { + "start": 64705, + "end": 64762 + } + }, + { + "id": "effect_887", + "effect_id": "effect@64787:64835", + "bound_var": "r744", + "source_text": "ctx.insert_t51_approx(b62.clone(), b743.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b62", + "b743" + ], + "range": { + "start": 64787, + "end": 64835 + } + }, + { + "id": "effect_888", + "effect_id": "effect@64849:64886", + "bound_var": null, + "source_text": "ctx.set_to_extract(750, r744.clone())", + "semantic_text": "to_extract(750) = r744", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r744" + ], + "range": { + "start": 64849, + "end": 64886 + } + }, + { + "id": "effect_889", + "effect_id": "effect@64911:64957", + "bound_var": "b745", + "source_text": "ctx.insert_t51_mul(b113.clone(), b683.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b683" + ], + "range": { + "start": 64911, + "end": 64957 + } + }, + { + "id": "effect_890", + "effect_id": "effect@64982:65027", + "bound_var": "b746", + "source_text": "ctx.insert_t51_sub(b745.clone(), b98.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b745", + "b98" + ], + "range": { + "start": 64982, + "end": 65027 + } + }, + { + "id": "effect_891", + "effect_id": "effect@65052:65102", + "bound_var": "b747", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b746.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b746", + "slambda2" + ], + "range": { + "start": 65052, + "end": 65102 + } + }, + { + "id": "effect_892", + "effect_id": "effect@65127:65177", + "bound_var": "b748", + "source_text": "ctx.insert_t51_add(slambda1.clone(), b747.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b747", + "slambda1" + ], + "range": { + "start": 65127, + "end": 65177 + } + }, + { + "id": "effect_893", + "effect_id": "effect@65202:65252", + "bound_var": "b749", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b748.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b748", + "slambda2" + ], + "range": { + "start": 65202, + "end": 65252 + } + }, + { + "id": "effect_894", + "effect_id": "effect@65277:65322", + "bound_var": "b750", + "source_text": "ctx.insert_t51_add(b87.clone(), b749.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b749", + "b87" + ], + "range": { + "start": 65277, + "end": 65322 + } + }, + { + "id": "effect_895", + "effect_id": "effect@65347:65404", + "bound_var": "b751", + "source_text": "ctx.insert_t51_lower(b750.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b750" + ], + "range": { + "start": 65347, + "end": 65404 + } + }, + { + "id": "effect_896", + "effect_id": "effect@65429:65477", + "bound_var": "r752", + "source_text": "ctx.insert_t51_approx(b62.clone(), b751.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b62", + "b751" + ], + "range": { + "start": 65429, + "end": 65477 + } + }, + { + "id": "effect_897", + "effect_id": "effect@65491:65528", + "bound_var": null, + "source_text": "ctx.set_to_extract(758, r752.clone())", + "semantic_text": "to_extract(758) = r752", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r752" + ], + "range": { + "start": 65491, + "end": 65528 + } + }, + { + "id": "effect_898", + "effect_id": "effect@65553:65599", + "bound_var": "b753", + "source_text": "ctx.insert_t51_mul(b113.clone(), b641.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b641" + ], + "range": { + "start": 65553, + "end": 65599 + } + }, + { + "id": "effect_899", + "effect_id": "effect@65624:65669", + "bound_var": "b754", + "source_text": "ctx.insert_t51_add(b87.clone(), b753.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b753", + "b87" + ], + "range": { + "start": 65624, + "end": 65669 + } + }, + { + "id": "effect_900", + "effect_id": "effect@65694:65744", + "bound_var": "b755", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b754.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b754", + "slambda2" + ], + "range": { + "start": 65694, + "end": 65744 + } + }, + { + "id": "effect_901", + "effect_id": "effect@65769:65826", + "bound_var": "b756", + "source_text": "ctx.insert_t51_lower(b755.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b755" + ], + "range": { + "start": 65769, + "end": 65826 + } + }, + { + "id": "effect_902", + "effect_id": "effect@65851:65899", + "bound_var": "r757", + "source_text": "ctx.insert_t51_approx(b33.clone(), b756.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b33", + "b756" + ], + "range": { + "start": 65851, + "end": 65899 + } + }, + { + "id": "effect_903", + "effect_id": "effect@65913:65950", + "bound_var": null, + "source_text": "ctx.set_to_extract(763, r757.clone())", + "semantic_text": "to_extract(763) = r757", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r757" + ], + "range": { + "start": 65913, + "end": 65950 + } + }, + { + "id": "effect_904", + "effect_id": "effect@65975:66021", + "bound_var": "b758", + "source_text": "ctx.insert_t51_mul(b119.clone(), b641.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b119", + "b641" + ], + "range": { + "start": 65975, + "end": 66021 + } + }, + { + "id": "effect_905", + "effect_id": "effect@66046:66091", + "bound_var": "b759", + "source_text": "ctx.insert_t51_sub(b758.clone(), b74.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b74", + "b758" + ], + "range": { + "start": 66046, + "end": 66091 + } + }, + { + "id": "effect_906", + "effect_id": "effect@66116:66162", + "bound_var": "b760", + "source_text": "ctx.insert_t51_mul(b641.clone(), b759.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b641", + "b759" + ], + "range": { + "start": 66116, + "end": 66162 + } + }, + { + "id": "effect_907", + "effect_id": "effect@66187:66232", + "bound_var": "b761", + "source_text": "ctx.insert_t51_add(b87.clone(), b760.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b760", + "b87" + ], + "range": { + "start": 66187, + "end": 66232 + } + }, + { + "id": "effect_908", + "effect_id": "effect@66257:66307", + "bound_var": "b762", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b761.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b761", + "slambda2" + ], + "range": { + "start": 66257, + "end": 66307 + } + }, + { + "id": "effect_909", + "effect_id": "effect@66332:66389", + "bound_var": "b763", + "source_text": "ctx.insert_t51_lower(b762.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b762" + ], + "range": { + "start": 66332, + "end": 66389 + } + }, + { + "id": "effect_910", + "effect_id": "effect@66414:66462", + "bound_var": "r764", + "source_text": "ctx.insert_t51_approx(b33.clone(), b763.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b33", + "b763" + ], + "range": { + "start": 66414, + "end": 66462 + } + }, + { + "id": "effect_911", + "effect_id": "effect@66476:66513", + "bound_var": null, + "source_text": "ctx.set_to_extract(770, r764.clone())", + "semantic_text": "to_extract(770) = r764", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r764" + ], + "range": { + "start": 66476, + "end": 66513 + } + }, + { + "id": "effect_912", + "effect_id": "effect@66538:66584", + "bound_var": "b765", + "source_text": "ctx.insert_t51_mul(b127.clone(), b641.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b127", + "b641" + ], + "range": { + "start": 66538, + "end": 66584 + } + }, + { + "id": "effect_913", + "effect_id": "effect@66609:66655", + "bound_var": "b766", + "source_text": "ctx.insert_t51_add(b119.clone(), b765.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b119", + "b765" + ], + "range": { + "start": 66609, + "end": 66655 + } + }, + { + "id": "effect_914", + "effect_id": "effect@66680:66726", + "bound_var": "b767", + "source_text": "ctx.insert_t51_mul(b641.clone(), b766.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b641", + "b766" + ], + "range": { + "start": 66680, + "end": 66726 + } + }, + { + "id": "effect_915", + "effect_id": "effect@66751:66796", + "bound_var": "b768", + "source_text": "ctx.insert_t51_sub(b767.clone(), b74.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b74", + "b767" + ], + "range": { + "start": 66751, + "end": 66796 + } + }, + { + "id": "effect_916", + "effect_id": "effect@66821:66867", + "bound_var": "b769", + "source_text": "ctx.insert_t51_mul(b641.clone(), b768.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b641", + "b768" + ], + "range": { + "start": 66821, + "end": 66867 + } + }, + { + "id": "effect_917", + "effect_id": "effect@66892:66937", + "bound_var": "b770", + "source_text": "ctx.insert_t51_add(b87.clone(), b769.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b769", + "b87" + ], + "range": { + "start": 66892, + "end": 66937 + } + }, + { + "id": "effect_918", + "effect_id": "effect@66962:67012", + "bound_var": "b771", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b770.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b770", + "slambda2" + ], + "range": { + "start": 66962, + "end": 67012 + } + }, + { + "id": "effect_919", + "effect_id": "effect@67037:67094", + "bound_var": "b772", + "source_text": "ctx.insert_t51_lower(b771.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b771" + ], + "range": { + "start": 67037, + "end": 67094 + } + }, + { + "id": "effect_920", + "effect_id": "effect@67119:67167", + "bound_var": "r773", + "source_text": "ctx.insert_t51_approx(b33.clone(), b772.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b33", + "b772" + ], + "range": { + "start": 67119, + "end": 67167 + } + }, + { + "id": "effect_921", + "effect_id": "effect@67181:67218", + "bound_var": null, + "source_text": "ctx.set_to_extract(779, r773.clone())", + "semantic_text": "to_extract(779) = r773", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r773" + ], + "range": { + "start": 67181, + "end": 67218 + } + }, + { + "id": "effect_922", + "effect_id": "effect@67243:67300", + "bound_var": "b774", + "source_text": "ctx.insert_t51_lower(b620.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b620" + ], + "range": { + "start": 67243, + "end": 67300 + } + }, + { + "id": "effect_923", + "effect_id": "effect@67325:67373", + "bound_var": "r775", + "source_text": "ctx.insert_t51_approx(b34.clone(), b774.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b34", + "b774" + ], + "range": { + "start": 67325, + "end": 67373 + } + }, + { + "id": "effect_924", + "effect_id": "effect@67387:67424", + "bound_var": null, + "source_text": "ctx.set_to_extract(781, r775.clone())", + "semantic_text": "to_extract(781) = r775", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r775" + ], + "range": { + "start": 67387, + "end": 67424 + } + }, + { + "id": "effect_925", + "effect_id": "effect@67449:67494", + "bound_var": "b776", + "source_text": "ctx.insert_t51_mul(b641.clone(), b32.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b32", + "b641" + ], + "range": { + "start": 67449, + "end": 67494 + } + }, + { + "id": "effect_926", + "effect_id": "effect@67519:67565", + "bound_var": "b777", + "source_text": "ctx.insert_t51_mul(b113.clone(), b776.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b776" + ], + "range": { + "start": 67519, + "end": 67565 + } + }, + { + "id": "effect_927", + "effect_id": "effect@67590:67635", + "bound_var": "b778", + "source_text": "ctx.insert_t51_add(b32.clone(), b777.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b32", + "b777" + ], + "range": { + "start": 67590, + "end": 67635 + } + }, + { + "id": "effect_928", + "effect_id": "effect@67660:67710", + "bound_var": "b779", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b778.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b778", + "slambda2" + ], + "range": { + "start": 67660, + "end": 67710 + } + }, + { + "id": "effect_929", + "effect_id": "effect@67735:67792", + "bound_var": "b780", + "source_text": "ctx.insert_t51_lower(b779.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b779" + ], + "range": { + "start": 67735, + "end": 67792 + } + }, + { + "id": "effect_930", + "effect_id": "effect@67817:67865", + "bound_var": "r781", + "source_text": "ctx.insert_t51_approx(b34.clone(), b780.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b34", + "b780" + ], + "range": { + "start": 67817, + "end": 67865 + } + }, + { + "id": "effect_931", + "effect_id": "effect@67879:67916", + "bound_var": null, + "source_text": "ctx.set_to_extract(787, r781.clone())", + "semantic_text": "to_extract(787) = r781", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r781" + ], + "range": { + "start": 67879, + "end": 67916 + } + }, + { + "id": "effect_932", + "effect_id": "effect@67941:67986", + "bound_var": "b782", + "source_text": "ctx.insert_t51_mul(b113.clone(), b32.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b32" + ], + "range": { + "start": 67941, + "end": 67986 + } + }, + { + "id": "effect_933", + "effect_id": "effect@68011:68057", + "bound_var": "b783", + "source_text": "ctx.insert_t51_mul(b119.clone(), b776.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b119", + "b776" + ], + "range": { + "start": 68011, + "end": 68057 + } + }, + { + "id": "effect_934", + "effect_id": "effect@68082:68128", + "bound_var": "b784", + "source_text": "ctx.insert_t51_add(b782.clone(), b783.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b782", + "b783" + ], + "range": { + "start": 68082, + "end": 68128 + } + }, + { + "id": "effect_935", + "effect_id": "effect@68153:68199", + "bound_var": "b785", + "source_text": "ctx.insert_t51_mul(b641.clone(), b784.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b641", + "b784" + ], + "range": { + "start": 68153, + "end": 68199 + } + }, + { + "id": "effect_936", + "effect_id": "effect@68224:68269", + "bound_var": "b786", + "source_text": "ctx.insert_t51_add(b32.clone(), b785.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b32", + "b785" + ], + "range": { + "start": 68224, + "end": 68269 + } + }, + { + "id": "effect_937", + "effect_id": "effect@68294:68344", + "bound_var": "b787", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b786.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b786", + "slambda2" + ], + "range": { + "start": 68294, + "end": 68344 + } + }, + { + "id": "effect_938", + "effect_id": "effect@68369:68426", + "bound_var": "b788", + "source_text": "ctx.insert_t51_lower(b787.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b787" + ], + "range": { + "start": 68369, + "end": 68426 + } + }, + { + "id": "effect_939", + "effect_id": "effect@68451:68499", + "bound_var": "r789", + "source_text": "ctx.insert_t51_approx(b34.clone(), b788.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b34", + "b788" + ], + "range": { + "start": 68451, + "end": 68499 + } + }, + { + "id": "effect_940", + "effect_id": "effect@68513:68550", + "bound_var": null, + "source_text": "ctx.set_to_extract(795, r789.clone())", + "semantic_text": "to_extract(795) = r789", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r789" + ], + "range": { + "start": 68513, + "end": 68550 + } + }, + { + "id": "effect_941", + "effect_id": "effect@68575:68621", + "bound_var": "b790", + "source_text": "ctx.insert_t51_mul(b127.clone(), b776.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b127", + "b776" + ], + "range": { + "start": 68575, + "end": 68621 + } + }, + { + "id": "effect_942", + "effect_id": "effect@68646:68691", + "bound_var": "b791", + "source_text": "ctx.insert_t51_mul(b119.clone(), b32.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b119", + "b32" + ], + "range": { + "start": 68646, + "end": 68691 + } + }, + { + "id": "effect_943", + "effect_id": "effect@68716:68762", + "bound_var": "b792", + "source_text": "ctx.insert_t51_add(b790.clone(), b791.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b790", + "b791" + ], + "range": { + "start": 68716, + "end": 68762 + } + }, + { + "id": "effect_944", + "effect_id": "effect@68787:68833", + "bound_var": "b793", + "source_text": "ctx.insert_t51_mul(b641.clone(), b792.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b641", + "b792" + ], + "range": { + "start": 68787, + "end": 68833 + } + }, + { + "id": "effect_945", + "effect_id": "effect@68858:68904", + "bound_var": "b794", + "source_text": "ctx.insert_t51_add(b782.clone(), b793.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b782", + "b793" + ], + "range": { + "start": 68858, + "end": 68904 + } + }, + { + "id": "effect_946", + "effect_id": "effect@68929:68975", + "bound_var": "b795", + "source_text": "ctx.insert_t51_mul(b641.clone(), b794.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b641", + "b794" + ], + "range": { + "start": 68929, + "end": 68975 + } + }, + { + "id": "effect_947", + "effect_id": "effect@69000:69045", + "bound_var": "b796", + "source_text": "ctx.insert_t51_add(b32.clone(), b795.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b32", + "b795" + ], + "range": { + "start": 69000, + "end": 69045 + } + }, + { + "id": "effect_948", + "effect_id": "effect@69070:69120", + "bound_var": "b797", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b796.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b796", + "slambda2" + ], + "range": { + "start": 69070, + "end": 69120 + } + }, + { + "id": "effect_949", + "effect_id": "effect@69145:69202", + "bound_var": "b798", + "source_text": "ctx.insert_t51_lower(b797.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b797" + ], + "range": { + "start": 69145, + "end": 69202 + } + }, + { + "id": "effect_950", + "effect_id": "effect@69227:69275", + "bound_var": "r799", + "source_text": "ctx.insert_t51_approx(b34.clone(), b798.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b34", + "b798" + ], + "range": { + "start": 69227, + "end": 69275 + } + }, + { + "id": "effect_951", + "effect_id": "effect@69289:69326", + "bound_var": null, + "source_text": "ctx.set_to_extract(805, r799.clone())", + "semantic_text": "to_extract(805) = r799", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r799" + ], + "range": { + "start": 69289, + "end": 69326 + } + }, + { + "id": "effect_952", + "effect_id": "effect@69351:69396", + "bound_var": "b800", + "source_text": "ctx.insert_t51_add(b32.clone(), b625.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b32", + "b625" + ], + "range": { + "start": 69351, + "end": 69396 + } + }, + { + "id": "effect_953", + "effect_id": "effect@69421:69471", + "bound_var": "b801", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b800.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b800", + "slambda2" + ], + "range": { + "start": 69421, + "end": 69471 + } + }, + { + "id": "effect_954", + "effect_id": "effect@69496:69541", + "bound_var": "b802", + "source_text": "ctx.insert_t51_add(b29.clone(), b801.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b29", + "b801" + ], + "range": { + "start": 69496, + "end": 69541 + } + }, + { + "id": "effect_955", + "effect_id": "effect@69566:69623", + "bound_var": "b803", + "source_text": "ctx.insert_t51_lower(b802.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b802" + ], + "range": { + "start": 69566, + "end": 69623 + } + }, + { + "id": "effect_956", + "effect_id": "effect@69648:69696", + "bound_var": "r804", + "source_text": "ctx.insert_t51_approx(b35.clone(), b803.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b35", + "b803" + ], + "range": { + "start": 69648, + "end": 69696 + } + }, + { + "id": "effect_957", + "effect_id": "effect@69710:69747", + "bound_var": null, + "source_text": "ctx.set_to_extract(810, r804.clone())", + "semantic_text": "to_extract(810) = r804", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r804" + ], + "range": { + "start": 69710, + "end": 69747 + } + }, + { + "id": "effect_958", + "effect_id": "effect@69772:69817", + "bound_var": "b805", + "source_text": "ctx.insert_t51_add(b32.clone(), b635.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b32", + "b635" + ], + "range": { + "start": 69772, + "end": 69817 + } + }, + { + "id": "effect_959", + "effect_id": "effect@69842:69892", + "bound_var": "b806", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b805.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b805", + "slambda2" + ], + "range": { + "start": 69842, + "end": 69892 + } + }, + { + "id": "effect_960", + "effect_id": "effect@69917:69962", + "bound_var": "b807", + "source_text": "ctx.insert_t51_add(b29.clone(), b806.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b29", + "b806" + ], + "range": { + "start": 69917, + "end": 69962 + } + }, + { + "id": "effect_961", + "effect_id": "effect@69987:70044", + "bound_var": "b808", + "source_text": "ctx.insert_t51_lower(b807.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b807" + ], + "range": { + "start": 69987, + "end": 70044 + } + }, + { + "id": "effect_962", + "effect_id": "effect@70069:70117", + "bound_var": "r809", + "source_text": "ctx.insert_t51_approx(b35.clone(), b808.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b35", + "b808" + ], + "range": { + "start": 70069, + "end": 70117 + } + }, + { + "id": "effect_963", + "effect_id": "effect@70131:70168", + "bound_var": null, + "source_text": "ctx.set_to_extract(815, r809.clone())", + "semantic_text": "to_extract(815) = r809", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r809" + ], + "range": { + "start": 70131, + "end": 70168 + } + }, + { + "id": "effect_964", + "effect_id": "effect@70193:70237", + "bound_var": "b810", + "source_text": "ctx.insert_t51_mul(b29.clone(), b13.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b13", + "b29" + ], + "range": { + "start": 70193, + "end": 70237 + } + }, + { + "id": "effect_965", + "effect_id": "effect@70262:70319", + "bound_var": "b811", + "source_text": "ctx.insert_t51_lower(b810.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b810" + ], + "range": { + "start": 70262, + "end": 70319 + } + }, + { + "id": "effect_966", + "effect_id": "effect@70344:70392", + "bound_var": "r812", + "source_text": "ctx.insert_t51_approx(b18.clone(), b811.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b18", + "b811" + ], + "range": { + "start": 70344, + "end": 70392 + } + }, + { + "id": "effect_967", + "effect_id": "effect@70406:70443", + "bound_var": null, + "source_text": "ctx.set_to_extract(818, r812.clone())", + "semantic_text": "to_extract(818) = r812", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r812" + ], + "range": { + "start": 70406, + "end": 70443 + } + }, + { + "id": "effect_968", + "effect_id": "effect@70468:70512", + "bound_var": "b813", + "source_text": "ctx.insert_t51_mul(b12.clone(), b32.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b12", + "b32" + ], + "range": { + "start": 70468, + "end": 70512 + } + }, + { + "id": "effect_969", + "effect_id": "effect@70537:70582", + "bound_var": "b814", + "source_text": "ctx.insert_t51_mul(b11.clone(), b813.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b11", + "b813" + ], + "range": { + "start": 70537, + "end": 70582 + } + }, + { + "id": "effect_970", + "effect_id": "effect@70607:70657", + "bound_var": "b815", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b814.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b814", + "slambda2" + ], + "range": { + "start": 70607, + "end": 70657 + } + }, + { + "id": "effect_971", + "effect_id": "effect@70682:70728", + "bound_var": "b816", + "source_text": "ctx.insert_t51_add(b815.clone(), b810.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b810", + "b815" + ], + "range": { + "start": 70682, + "end": 70728 + } + }, + { + "id": "effect_972", + "effect_id": "effect@70753:70810", + "bound_var": "b817", + "source_text": "ctx.insert_t51_lower(b816.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b816" + ], + "range": { + "start": 70753, + "end": 70810 + } + }, + { + "id": "effect_973", + "effect_id": "effect@70835:70883", + "bound_var": "r818", + "source_text": "ctx.insert_t51_approx(b18.clone(), b817.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b18", + "b817" + ], + "range": { + "start": 70835, + "end": 70883 + } + }, + { + "id": "effect_974", + "effect_id": "effect@70897:70934", + "bound_var": null, + "source_text": "ctx.set_to_extract(824, r818.clone())", + "semantic_text": "to_extract(824) = r818", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r818" + ], + "range": { + "start": 70897, + "end": 70934 + } + }, + { + "id": "effect_975", + "effect_id": "effect@70959:71009", + "bound_var": "b819", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b810.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b810", + "slambda2" + ], + "range": { + "start": 70959, + "end": 71009 + } + }, + { + "id": "effect_976", + "effect_id": "effect@71034:71079", + "bound_var": "b820", + "source_text": "ctx.insert_t51_mul(b65.clone(), b819.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b65", + "b819" + ], + "range": { + "start": 71034, + "end": 71079 + } + }, + { + "id": "effect_977", + "effect_id": "effect@71104:71150", + "bound_var": "b821", + "source_text": "ctx.insert_t51_add(b820.clone(), b814.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b814", + "b820" + ], + "range": { + "start": 71104, + "end": 71150 + } + }, + { + "id": "effect_978", + "effect_id": "effect@71175:71225", + "bound_var": "b822", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b821.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b821", + "slambda2" + ], + "range": { + "start": 71175, + "end": 71225 + } + }, + { + "id": "effect_979", + "effect_id": "effect@71250:71296", + "bound_var": "b823", + "source_text": "ctx.insert_t51_add(b822.clone(), b810.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b810", + "b822" + ], + "range": { + "start": 71250, + "end": 71296 + } + }, + { + "id": "effect_980", + "effect_id": "effect@71321:71378", + "bound_var": "b824", + "source_text": "ctx.insert_t51_lower(b823.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b823" + ], + "range": { + "start": 71321, + "end": 71378 + } + }, + { + "id": "effect_981", + "effect_id": "effect@71403:71451", + "bound_var": "r825", + "source_text": "ctx.insert_t51_approx(b18.clone(), b824.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b18", + "b824" + ], + "range": { + "start": 71403, + "end": 71451 + } + }, + { + "id": "effect_982", + "effect_id": "effect@71465:71502", + "bound_var": null, + "source_text": "ctx.set_to_extract(831, r825.clone())", + "semantic_text": "to_extract(831) = r825", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r825" + ], + "range": { + "start": 71465, + "end": 71502 + } + }, + { + "id": "effect_983", + "effect_id": "effect@71527:71572", + "bound_var": "b826", + "source_text": "ctx.insert_t51_mul(b65.clone(), b810.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b65", + "b810" + ], + "range": { + "start": 71527, + "end": 71572 + } + }, + { + "id": "effect_984", + "effect_id": "effect@71597:71643", + "bound_var": "b827", + "source_text": "ctx.insert_t51_mul(b113.clone(), b815.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b815" + ], + "range": { + "start": 71597, + "end": 71643 + } + }, + { + "id": "effect_985", + "effect_id": "effect@71668:71714", + "bound_var": "b828", + "source_text": "ctx.insert_t51_add(b826.clone(), b827.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b826", + "b827" + ], + "range": { + "start": 71668, + "end": 71714 + } + }, + { + "id": "effect_986", + "effect_id": "effect@71739:71789", + "bound_var": "b829", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b828.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b828", + "slambda2" + ], + "range": { + "start": 71739, + "end": 71789 + } + }, + { + "id": "effect_987", + "effect_id": "effect@71814:71860", + "bound_var": "b830", + "source_text": "ctx.insert_t51_add(b829.clone(), b814.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b814", + "b829" + ], + "range": { + "start": 71814, + "end": 71860 + } + }, + { + "id": "effect_988", + "effect_id": "effect@71885:71935", + "bound_var": "b831", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b830.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b830", + "slambda2" + ], + "range": { + "start": 71885, + "end": 71935 + } + }, + { + "id": "effect_989", + "effect_id": "effect@71960:72006", + "bound_var": "b832", + "source_text": "ctx.insert_t51_add(b831.clone(), b810.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b810", + "b831" + ], + "range": { + "start": 71960, + "end": 72006 + } + }, + { + "id": "effect_990", + "effect_id": "effect@72031:72088", + "bound_var": "b833", + "source_text": "ctx.insert_t51_lower(b832.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b832" + ], + "range": { + "start": 72031, + "end": 72088 + } + }, + { + "id": "effect_991", + "effect_id": "effect@72113:72161", + "bound_var": "r834", + "source_text": "ctx.insert_t51_approx(b18.clone(), b833.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b18", + "b833" + ], + "range": { + "start": 72113, + "end": 72161 + } + }, + { + "id": "effect_992", + "effect_id": "effect@72175:72212", + "bound_var": null, + "source_text": "ctx.set_to_extract(840, r834.clone())", + "semantic_text": "to_extract(840) = r834", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r834" + ], + "range": { + "start": 72175, + "end": 72212 + } + }, + { + "id": "effect_993", + "effect_id": "effect@72237:72281", + "bound_var": "b835", + "source_text": "ctx.insert_t51_mul(b29.clone(), b12.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b12", + "b29" + ], + "range": { + "start": 72237, + "end": 72281 + } + }, + { + "id": "effect_994", + "effect_id": "effect@72306:72363", + "bound_var": "b836", + "source_text": "ctx.insert_t51_lower(b835.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b835" + ], + "range": { + "start": 72306, + "end": 72363 + } + }, + { + "id": "effect_995", + "effect_id": "effect@72388:72436", + "bound_var": "r837", + "source_text": "ctx.insert_t51_approx(b40.clone(), b836.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b40", + "b836" + ], + "range": { + "start": 72388, + "end": 72436 + } + }, + { + "id": "effect_996", + "effect_id": "effect@72450:72487", + "bound_var": null, + "source_text": "ctx.set_to_extract(843, r837.clone())", + "semantic_text": "to_extract(843) = r837", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r837" + ], + "range": { + "start": 72450, + "end": 72487 + } + }, + { + "id": "effect_997", + "effect_id": "effect@72512:72562", + "bound_var": "b838", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b813.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b813", + "slambda2" + ], + "range": { + "start": 72512, + "end": 72562 + } + }, + { + "id": "effect_998", + "effect_id": "effect@72587:72633", + "bound_var": "b839", + "source_text": "ctx.insert_t51_add(b838.clone(), b835.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b835", + "b838" + ], + "range": { + "start": 72587, + "end": 72633 + } + }, + { + "id": "effect_999", + "effect_id": "effect@72658:72715", + "bound_var": "b840", + "source_text": "ctx.insert_t51_lower(b839.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b839" + ], + "range": { + "start": 72658, + "end": 72715 + } + }, + { + "id": "effect_1000", + "effect_id": "effect@72740:72788", + "bound_var": "r841", + "source_text": "ctx.insert_t51_approx(b40.clone(), b840.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b40", + "b840" + ], + "range": { + "start": 72740, + "end": 72788 + } + }, + { + "id": "effect_1001", + "effect_id": "effect@72802:72839", + "bound_var": null, + "source_text": "ctx.set_to_extract(847, r841.clone())", + "semantic_text": "to_extract(847) = r841", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r841" + ], + "range": { + "start": 72802, + "end": 72839 + } + }, + { + "id": "effect_1002", + "effect_id": "effect@72864:72914", + "bound_var": "b842", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b835.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b835", + "slambda2" + ], + "range": { + "start": 72864, + "end": 72914 + } + }, + { + "id": "effect_1003", + "effect_id": "effect@72939:72984", + "bound_var": "b843", + "source_text": "ctx.insert_t51_mul(b65.clone(), b842.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b65", + "b842" + ], + "range": { + "start": 72939, + "end": 72984 + } + }, + { + "id": "effect_1004", + "effect_id": "effect@73009:73055", + "bound_var": "b844", + "source_text": "ctx.insert_t51_add(b843.clone(), b813.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b813", + "b843" + ], + "range": { + "start": 73009, + "end": 73055 + } + }, + { + "id": "effect_1005", + "effect_id": "effect@73080:73130", + "bound_var": "b845", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b844.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b844", + "slambda2" + ], + "range": { + "start": 73080, + "end": 73130 + } + }, + { + "id": "effect_1006", + "effect_id": "effect@73155:73201", + "bound_var": "b846", + "source_text": "ctx.insert_t51_add(b845.clone(), b835.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b835", + "b845" + ], + "range": { + "start": 73155, + "end": 73201 + } + }, + { + "id": "effect_1007", + "effect_id": "effect@73226:73283", + "bound_var": "b847", + "source_text": "ctx.insert_t51_lower(b846.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b846" + ], + "range": { + "start": 73226, + "end": 73283 + } + }, + { + "id": "effect_1008", + "effect_id": "effect@73308:73356", + "bound_var": "r848", + "source_text": "ctx.insert_t51_approx(b40.clone(), b847.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b40", + "b847" + ], + "range": { + "start": 73308, + "end": 73356 + } + }, + { + "id": "effect_1009", + "effect_id": "effect@73370:73407", + "bound_var": null, + "source_text": "ctx.set_to_extract(854, r848.clone())", + "semantic_text": "to_extract(854) = r848", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r848" + ], + "range": { + "start": 73370, + "end": 73407 + } + }, + { + "id": "effect_1010", + "effect_id": "effect@73432:73477", + "bound_var": "b849", + "source_text": "ctx.insert_t51_mul(b65.clone(), b835.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b65", + "b835" + ], + "range": { + "start": 73432, + "end": 73477 + } + }, + { + "id": "effect_1011", + "effect_id": "effect@73502:73548", + "bound_var": "b850", + "source_text": "ctx.insert_t51_mul(b113.clone(), b838.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b838" + ], + "range": { + "start": 73502, + "end": 73548 + } + }, + { + "id": "effect_1012", + "effect_id": "effect@73573:73619", + "bound_var": "b851", + "source_text": "ctx.insert_t51_add(b849.clone(), b850.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b849", + "b850" + ], + "range": { + "start": 73573, + "end": 73619 + } + }, + { + "id": "effect_1013", + "effect_id": "effect@73644:73694", + "bound_var": "b852", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b851.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b851", + "slambda2" + ], + "range": { + "start": 73644, + "end": 73694 + } + }, + { + "id": "effect_1014", + "effect_id": "effect@73719:73765", + "bound_var": "b853", + "source_text": "ctx.insert_t51_add(b852.clone(), b813.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b813", + "b852" + ], + "range": { + "start": 73719, + "end": 73765 + } + }, + { + "id": "effect_1015", + "effect_id": "effect@73790:73840", + "bound_var": "b854", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b853.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b853", + "slambda2" + ], + "range": { + "start": 73790, + "end": 73840 + } + }, + { + "id": "effect_1016", + "effect_id": "effect@73865:73911", + "bound_var": "b855", + "source_text": "ctx.insert_t51_add(b854.clone(), b835.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b835", + "b854" + ], + "range": { + "start": 73865, + "end": 73911 + } + }, + { + "id": "effect_1017", + "effect_id": "effect@73936:73993", + "bound_var": "b856", + "source_text": "ctx.insert_t51_lower(b855.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b855" + ], + "range": { + "start": 73936, + "end": 73993 + } + }, + { + "id": "effect_1018", + "effect_id": "effect@74018:74066", + "bound_var": "r857", + "source_text": "ctx.insert_t51_approx(b40.clone(), b856.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b40", + "b856" + ], + "range": { + "start": 74018, + "end": 74066 + } + }, + { + "id": "effect_1019", + "effect_id": "effect@74080:74117", + "bound_var": null, + "source_text": "ctx.set_to_extract(863, r857.clone())", + "semantic_text": "to_extract(863) = r857", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r857" + ], + "range": { + "start": 74080, + "end": 74117 + } + }, + { + "id": "effect_1020", + "effect_id": "effect@74142:74187", + "bound_var": "b858", + "source_text": "ctx.insert_t51_add(b810.clone(), b10.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b10", + "b810" + ], + "range": { + "start": 74142, + "end": 74187 + } + }, + { + "id": "effect_1021", + "effect_id": "effect@74212:74269", + "bound_var": "b859", + "source_text": "ctx.insert_t51_lower(b858.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b858" + ], + "range": { + "start": 74212, + "end": 74269 + } + }, + { + "id": "effect_1022", + "effect_id": "effect@74294:74342", + "bound_var": "r860", + "source_text": "ctx.insert_t51_approx(b42.clone(), b859.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b42", + "b859" + ], + "range": { + "start": 74294, + "end": 74342 + } + }, + { + "id": "effect_1023", + "effect_id": "effect@74356:74393", + "bound_var": null, + "source_text": "ctx.set_to_extract(866, r860.clone())", + "semantic_text": "to_extract(866) = r860", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r860" + ], + "range": { + "start": 74356, + "end": 74393 + } + }, + { + "id": "effect_1024", + "effect_id": "effect@74418:74464", + "bound_var": "b861", + "source_text": "ctx.insert_t51_add(b815.clone(), b858.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b815", + "b858" + ], + "range": { + "start": 74418, + "end": 74464 + } + }, + { + "id": "effect_1025", + "effect_id": "effect@74489:74546", + "bound_var": "b862", + "source_text": "ctx.insert_t51_lower(b861.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b861" + ], + "range": { + "start": 74489, + "end": 74546 + } + }, + { + "id": "effect_1026", + "effect_id": "effect@74571:74619", + "bound_var": "r863", + "source_text": "ctx.insert_t51_approx(b42.clone(), b862.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b42", + "b862" + ], + "range": { + "start": 74571, + "end": 74619 + } + }, + { + "id": "effect_1027", + "effect_id": "effect@74633:74670", + "bound_var": null, + "source_text": "ctx.set_to_extract(869, r863.clone())", + "semantic_text": "to_extract(869) = r863", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r863" + ], + "range": { + "start": 74633, + "end": 74670 + } + }, + { + "id": "effect_1028", + "effect_id": "effect@74695:74741", + "bound_var": "b864", + "source_text": "ctx.insert_t51_add(b822.clone(), b858.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b822", + "b858" + ], + "range": { + "start": 74695, + "end": 74741 + } + }, + { + "id": "effect_1029", + "effect_id": "effect@74766:74823", + "bound_var": "b865", + "source_text": "ctx.insert_t51_lower(b864.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b864" + ], + "range": { + "start": 74766, + "end": 74823 + } + }, + { + "id": "effect_1030", + "effect_id": "effect@74848:74896", + "bound_var": "r866", + "source_text": "ctx.insert_t51_approx(b42.clone(), b865.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b42", + "b865" + ], + "range": { + "start": 74848, + "end": 74896 + } + }, + { + "id": "effect_1031", + "effect_id": "effect@74910:74947", + "bound_var": null, + "source_text": "ctx.set_to_extract(872, r866.clone())", + "semantic_text": "to_extract(872) = r866", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r866" + ], + "range": { + "start": 74910, + "end": 74947 + } + }, + { + "id": "effect_1032", + "effect_id": "effect@74972:75018", + "bound_var": "b867", + "source_text": "ctx.insert_t51_add(b831.clone(), b858.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b831", + "b858" + ], + "range": { + "start": 74972, + "end": 75018 + } + }, + { + "id": "effect_1033", + "effect_id": "effect@75043:75100", + "bound_var": "b868", + "source_text": "ctx.insert_t51_lower(b867.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b867" + ], + "range": { + "start": 75043, + "end": 75100 + } + }, + { + "id": "effect_1034", + "effect_id": "effect@75125:75173", + "bound_var": "r869", + "source_text": "ctx.insert_t51_approx(b42.clone(), b868.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b42", + "b868" + ], + "range": { + "start": 75125, + "end": 75173 + } + }, + { + "id": "effect_1035", + "effect_id": "effect@75187:75224", + "bound_var": null, + "source_text": "ctx.set_to_extract(875, r869.clone())", + "semantic_text": "to_extract(875) = r869", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r869" + ], + "range": { + "start": 75187, + "end": 75224 + } + }, + { + "id": "effect_1036", + "effect_id": "effect@75249:75294", + "bound_var": "b870", + "source_text": "ctx.insert_t51_add(b29.clone(), b262.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b262", + "b29" + ], + "range": { + "start": 75249, + "end": 75294 + } + }, + { + "id": "effect_1037", + "effect_id": "effect@75319:75376", + "bound_var": "b871", + "source_text": "ctx.insert_t51_lower(b870.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b870" + ], + "range": { + "start": 75319, + "end": 75376 + } + }, + { + "id": "effect_1038", + "effect_id": "effect@75401:75450", + "bound_var": "r872", + "source_text": "ctx.insert_t51_approx(b263.clone(), b871.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b263", + "b871" + ], + "range": { + "start": 75401, + "end": 75450 + } + }, + { + "id": "effect_1039", + "effect_id": "effect@75464:75501", + "bound_var": null, + "source_text": "ctx.set_to_extract(878, r872.clone())", + "semantic_text": "to_extract(878) = r872", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r872" + ], + "range": { + "start": 75464, + "end": 75501 + } + }, + { + "id": "effect_1040", + "effect_id": "effect@75526:75572", + "bound_var": "b873", + "source_text": "ctx.insert_t51_add(b620.clone(), b262.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b262", + "b620" + ], + "range": { + "start": 75526, + "end": 75572 + } + }, + { + "id": "effect_1041", + "effect_id": "effect@75597:75642", + "bound_var": "b874", + "source_text": "ctx.insert_t51_add(b29.clone(), b873.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b29", + "b873" + ], + "range": { + "start": 75597, + "end": 75642 + } + }, + { + "id": "effect_1042", + "effect_id": "effect@75667:75724", + "bound_var": "b875", + "source_text": "ctx.insert_t51_lower(b874.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b874" + ], + "range": { + "start": 75667, + "end": 75724 + } + }, + { + "id": "effect_1043", + "effect_id": "effect@75749:75798", + "bound_var": "r876", + "source_text": "ctx.insert_t51_approx(b263.clone(), b875.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b263", + "b875" + ], + "range": { + "start": 75749, + "end": 75798 + } + }, + { + "id": "effect_1044", + "effect_id": "effect@75812:75849", + "bound_var": null, + "source_text": "ctx.set_to_extract(882, r876.clone())", + "semantic_text": "to_extract(882) = r876", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r876" + ], + "range": { + "start": 75812, + "end": 75849 + } + }, + { + "id": "effect_1045", + "effect_id": "effect@75874:75920", + "bound_var": "b877", + "source_text": "ctx.insert_t51_add(b628.clone(), b262.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b262", + "b628" + ], + "range": { + "start": 75874, + "end": 75920 + } + }, + { + "id": "effect_1046", + "effect_id": "effect@75945:75990", + "bound_var": "b878", + "source_text": "ctx.insert_t51_add(b29.clone(), b877.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b29", + "b877" + ], + "range": { + "start": 75945, + "end": 75990 + } + }, + { + "id": "effect_1047", + "effect_id": "effect@76015:76072", + "bound_var": "b879", + "source_text": "ctx.insert_t51_lower(b878.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b878" + ], + "range": { + "start": 76015, + "end": 76072 + } + }, + { + "id": "effect_1048", + "effect_id": "effect@76097:76146", + "bound_var": "r880", + "source_text": "ctx.insert_t51_approx(b263.clone(), b879.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b263", + "b879" + ], + "range": { + "start": 76097, + "end": 76146 + } + }, + { + "id": "effect_1049", + "effect_id": "effect@76160:76197", + "bound_var": null, + "source_text": "ctx.set_to_extract(886, r880.clone())", + "semantic_text": "to_extract(886) = r880", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r880" + ], + "range": { + "start": 76160, + "end": 76197 + } + }, + { + "id": "effect_1050", + "effect_id": "effect@76222:76268", + "bound_var": "b881", + "source_text": "ctx.insert_t51_add(b637.clone(), b262.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b262", + "b637" + ], + "range": { + "start": 76222, + "end": 76268 + } + }, + { + "id": "effect_1051", + "effect_id": "effect@76293:76338", + "bound_var": "b882", + "source_text": "ctx.insert_t51_add(b29.clone(), b881.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b29", + "b881" + ], + "range": { + "start": 76293, + "end": 76338 + } + }, + { + "id": "effect_1052", + "effect_id": "effect@76363:76420", + "bound_var": "b883", + "source_text": "ctx.insert_t51_lower(b882.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b882" + ], + "range": { + "start": 76363, + "end": 76420 + } + }, + { + "id": "effect_1053", + "effect_id": "effect@76445:76494", + "bound_var": "r884", + "source_text": "ctx.insert_t51_approx(b263.clone(), b883.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b263", + "b883" + ], + "range": { + "start": 76445, + "end": 76494 + } + }, + { + "id": "effect_1054", + "effect_id": "effect@76508:76545", + "bound_var": null, + "source_text": "ctx.set_to_extract(890, r884.clone())", + "semantic_text": "to_extract(890) = r884", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r884" + ], + "range": { + "start": 76508, + "end": 76545 + } + }, + { + "id": "effect_1055", + "effect_id": "effect@76570:76616", + "bound_var": "b885", + "source_text": "ctx.insert_t51_add(b279.clone(), b835.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b279", + "b835" + ], + "range": { + "start": 76570, + "end": 76616 + } + }, + { + "id": "effect_1056", + "effect_id": "effect@76641:76698", + "bound_var": "b886", + "source_text": "ctx.insert_t51_lower(b885.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b885" + ], + "range": { + "start": 76641, + "end": 76698 + } + }, + { + "id": "effect_1057", + "effect_id": "effect@76723:76772", + "bound_var": "r887", + "source_text": "ctx.insert_t51_approx(b280.clone(), b886.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b280", + "b886" + ], + "range": { + "start": 76723, + "end": 76772 + } + }, + { + "id": "effect_1058", + "effect_id": "effect@76786:76823", + "bound_var": null, + "source_text": "ctx.set_to_extract(893, r887.clone())", + "semantic_text": "to_extract(893) = r887", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r887" + ], + "range": { + "start": 76786, + "end": 76823 + } + }, + { + "id": "effect_1059", + "effect_id": "effect@76848:76894", + "bound_var": "b888", + "source_text": "ctx.insert_t51_add(b838.clone(), b885.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b838", + "b885" + ], + "range": { + "start": 76848, + "end": 76894 + } + }, + { + "id": "effect_1060", + "effect_id": "effect@76919:76976", + "bound_var": "b889", + "source_text": "ctx.insert_t51_lower(b888.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b888" + ], + "range": { + "start": 76919, + "end": 76976 + } + }, + { + "id": "effect_1061", + "effect_id": "effect@77001:77050", + "bound_var": "r890", + "source_text": "ctx.insert_t51_approx(b280.clone(), b889.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b280", + "b889" + ], + "range": { + "start": 77001, + "end": 77050 + } + }, + { + "id": "effect_1062", + "effect_id": "effect@77064:77101", + "bound_var": null, + "source_text": "ctx.set_to_extract(896, r890.clone())", + "semantic_text": "to_extract(896) = r890", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r890" + ], + "range": { + "start": 77064, + "end": 77101 + } + }, + { + "id": "effect_1063", + "effect_id": "effect@77126:77172", + "bound_var": "b891", + "source_text": "ctx.insert_t51_add(b845.clone(), b885.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b845", + "b885" + ], + "range": { + "start": 77126, + "end": 77172 + } + }, + { + "id": "effect_1064", + "effect_id": "effect@77197:77254", + "bound_var": "b892", + "source_text": "ctx.insert_t51_lower(b891.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b891" + ], + "range": { + "start": 77197, + "end": 77254 + } + }, + { + "id": "effect_1065", + "effect_id": "effect@77279:77328", + "bound_var": "r893", + "source_text": "ctx.insert_t51_approx(b280.clone(), b892.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b280", + "b892" + ], + "range": { + "start": 77279, + "end": 77328 + } + }, + { + "id": "effect_1066", + "effect_id": "effect@77342:77379", + "bound_var": null, + "source_text": "ctx.set_to_extract(899, r893.clone())", + "semantic_text": "to_extract(899) = r893", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r893" + ], + "range": { + "start": 77342, + "end": 77379 + } + }, + { + "id": "effect_1067", + "effect_id": "effect@77404:77450", + "bound_var": "b894", + "source_text": "ctx.insert_t51_add(b854.clone(), b885.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b854", + "b885" + ], + "range": { + "start": 77404, + "end": 77450 + } + }, + { + "id": "effect_1068", + "effect_id": "effect@77475:77532", + "bound_var": "b895", + "source_text": "ctx.insert_t51_lower(b894.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b894" + ], + "range": { + "start": 77475, + "end": 77532 + } + }, + { + "id": "effect_1069", + "effect_id": "effect@77557:77606", + "bound_var": "r896", + "source_text": "ctx.insert_t51_approx(b280.clone(), b895.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b280", + "b895" + ], + "range": { + "start": 77557, + "end": 77606 + } + }, + { + "id": "effect_1070", + "effect_id": "effect@77620:77657", + "bound_var": null, + "source_text": "ctx.set_to_extract(902, r896.clone())", + "semantic_text": "to_extract(902) = r896", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r896" + ], + "range": { + "start": 77620, + "end": 77657 + } + }, + { + "id": "effect_1071", + "effect_id": "effect@77682:77739", + "bound_var": "b897", + "source_text": "ctx.insert_t51_lower(b312.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b312" + ], + "range": { + "start": 77682, + "end": 77739 + } + }, + { + "id": "effect_1072", + "effect_id": "effect@77764:77813", + "bound_var": "r898", + "source_text": "ctx.insert_t51_approx(b308.clone(), b897.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b308", + "b897" + ], + "range": { + "start": 77764, + "end": 77813 + } + }, + { + "id": "effect_1073", + "effect_id": "effect@77827:77864", + "bound_var": null, + "source_text": "ctx.set_to_extract(904, r898.clone())", + "semantic_text": "to_extract(904) = r898", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r898" + ], + "range": { + "start": 77827, + "end": 77864 + } + }, + { + "id": "effect_1074", + "effect_id": "effect@77889:77934", + "bound_var": "b899", + "source_text": "ctx.insert_t51_add(b50.clone(), b307.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b307", + "b50" + ], + "range": { + "start": 77889, + "end": 77934 + } + }, + { + "id": "effect_1075", + "effect_id": "effect@77959:78009", + "bound_var": "b900", + "source_text": "ctx.insert_t51_add(slambda1.clone(), b899.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b899", + "slambda1" + ], + "range": { + "start": 77959, + "end": 78009 + } + }, + { + "id": "effect_1076", + "effect_id": "effect@78034:78091", + "bound_var": "b901", + "source_text": "ctx.insert_t51_lower(b900.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b900" + ], + "range": { + "start": 78034, + "end": 78091 + } + }, + { + "id": "effect_1077", + "effect_id": "effect@78116:78165", + "bound_var": "r902", + "source_text": "ctx.insert_t51_approx(b308.clone(), b901.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b308", + "b901" + ], + "range": { + "start": 78116, + "end": 78165 + } + }, + { + "id": "effect_1078", + "effect_id": "effect@78179:78216", + "bound_var": null, + "source_text": "ctx.set_to_extract(908, r902.clone())", + "semantic_text": "to_extract(908) = r902", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r902" + ], + "range": { + "start": 78179, + "end": 78216 + } + }, + { + "id": "effect_1079", + "effect_id": "effect@78241:78288", + "bound_var": "b903", + "source_text": "ctx.insert_t51_sub(b312.clone(), sphi2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b312", + "sphi2" + ], + "range": { + "start": 78241, + "end": 78288 + } + }, + { + "id": "effect_1080", + "effect_id": "effect@78313:78370", + "bound_var": "b904", + "source_text": "ctx.insert_t51_lower(b903.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b903" + ], + "range": { + "start": 78313, + "end": 78370 + } + }, + { + "id": "effect_1081", + "effect_id": "effect@78395:78444", + "bound_var": "r905", + "source_text": "ctx.insert_t51_approx(b316.clone(), b904.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b316", + "b904" + ], + "range": { + "start": 78395, + "end": 78444 + } + }, + { + "id": "effect_1082", + "effect_id": "effect@78458:78495", + "bound_var": null, + "source_text": "ctx.set_to_extract(911, r905.clone())", + "semantic_text": "to_extract(911) = r905", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r905" + ], + "range": { + "start": 78458, + "end": 78495 + } + }, + { + "id": "effect_1083", + "effect_id": "effect@78520:78567", + "bound_var": "b906", + "source_text": "ctx.insert_t51_sub(b900.clone(), sphi2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b900", + "sphi2" + ], + "range": { + "start": 78520, + "end": 78567 + } + }, + { + "id": "effect_1084", + "effect_id": "effect@78592:78649", + "bound_var": "b907", + "source_text": "ctx.insert_t51_lower(b906.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b906" + ], + "range": { + "start": 78592, + "end": 78649 + } + }, + { + "id": "effect_1085", + "effect_id": "effect@78674:78723", + "bound_var": "r908", + "source_text": "ctx.insert_t51_approx(b316.clone(), b907.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b316", + "b907" + ], + "range": { + "start": 78674, + "end": 78723 + } + }, + { + "id": "effect_1086", + "effect_id": "effect@78737:78774", + "bound_var": null, + "source_text": "ctx.set_to_extract(914, r908.clone())", + "semantic_text": "to_extract(914) = r908", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r908" + ], + "range": { + "start": 78737, + "end": 78774 + } + }, + { + "id": "effect_1087", + "effect_id": "effect@78799:78831", + "bound_var": "b909", + "source_text": "ctx.insert_t51_sin(b903.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b903" + ], + "range": { + "start": 78799, + "end": 78831 + } + }, + { + "id": "effect_1088", + "effect_id": "effect@78856:78913", + "bound_var": "b910", + "source_text": "ctx.insert_t51_lower(b909.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b909" + ], + "range": { + "start": 78856, + "end": 78913 + } + }, + { + "id": "effect_1089", + "effect_id": "effect@78938:78987", + "bound_var": "r911", + "source_text": "ctx.insert_t51_approx(b324.clone(), b910.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b324", + "b910" + ], + "range": { + "start": 78938, + "end": 78987 + } + }, + { + "id": "effect_1090", + "effect_id": "effect@79001:79038", + "bound_var": null, + "source_text": "ctx.set_to_extract(917, r911.clone())", + "semantic_text": "to_extract(917) = r911", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r911" + ], + "range": { + "start": 79001, + "end": 79038 + } + }, + { + "id": "effect_1091", + "effect_id": "effect@79063:79095", + "bound_var": "b912", + "source_text": "ctx.insert_t51_cos(b903.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b903" + ], + "range": { + "start": 79063, + "end": 79095 + } + }, + { + "id": "effect_1092", + "effect_id": "effect@79120:79170", + "bound_var": "b913", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b912.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b912", + "slambda2" + ], + "range": { + "start": 79120, + "end": 79170 + } + }, + { + "id": "effect_1093", + "effect_id": "effect@79195:79240", + "bound_var": "b914", + "source_text": "ctx.insert_t51_mul(b49.clone(), b913.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b49", + "b913" + ], + "range": { + "start": 79195, + "end": 79240 + } + }, + { + "id": "effect_1094", + "effect_id": "effect@79265:79311", + "bound_var": "b915", + "source_text": "ctx.insert_t51_add(b909.clone(), b914.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b909", + "b914" + ], + "range": { + "start": 79265, + "end": 79311 + } + }, + { + "id": "effect_1095", + "effect_id": "effect@79336:79393", + "bound_var": "b916", + "source_text": "ctx.insert_t51_lower(b915.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b915" + ], + "range": { + "start": 79336, + "end": 79393 + } + }, + { + "id": "effect_1096", + "effect_id": "effect@79418:79467", + "bound_var": "r917", + "source_text": "ctx.insert_t51_approx(b324.clone(), b916.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b324", + "b916" + ], + "range": { + "start": 79418, + "end": 79467 + } + }, + { + "id": "effect_1097", + "effect_id": "effect@79481:79518", + "bound_var": null, + "source_text": "ctx.set_to_extract(923, r917.clone())", + "semantic_text": "to_extract(923) = r917", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r917" + ], + "range": { + "start": 79481, + "end": 79518 + } + }, + { + "id": "effect_1098", + "effect_id": "effect@79543:79588", + "bound_var": "b918", + "source_text": "ctx.insert_t51_mul(b49.clone(), b912.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b49", + "b912" + ], + "range": { + "start": 79543, + "end": 79588 + } + }, + { + "id": "effect_1099", + "effect_id": "effect@79613:79663", + "bound_var": "b919", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b909.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b909", + "slambda2" + ], + "range": { + "start": 79613, + "end": 79663 + } + }, + { + "id": "effect_1100", + "effect_id": "effect@79688:79733", + "bound_var": "b920", + "source_text": "ctx.insert_t51_mul(b65.clone(), b919.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b65", + "b919" + ], + "range": { + "start": 79688, + "end": 79733 + } + }, + { + "id": "effect_1101", + "effect_id": "effect@79758:79804", + "bound_var": "b921", + "source_text": "ctx.insert_t51_add(b918.clone(), b920.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b918", + "b920" + ], + "range": { + "start": 79758, + "end": 79804 + } + }, + { + "id": "effect_1102", + "effect_id": "effect@79829:79879", + "bound_var": "b922", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b921.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b921", + "slambda2" + ], + "range": { + "start": 79829, + "end": 79879 + } + }, + { + "id": "effect_1103", + "effect_id": "effect@79904:79950", + "bound_var": "b923", + "source_text": "ctx.insert_t51_add(b909.clone(), b922.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b909", + "b922" + ], + "range": { + "start": 79904, + "end": 79950 + } + }, + { + "id": "effect_1104", + "effect_id": "effect@79975:80032", + "bound_var": "b924", + "source_text": "ctx.insert_t51_lower(b923.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b923" + ], + "range": { + "start": 79975, + "end": 80032 + } + }, + { + "id": "effect_1105", + "effect_id": "effect@80057:80106", + "bound_var": "r925", + "source_text": "ctx.insert_t51_approx(b324.clone(), b924.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b324", + "b924" + ], + "range": { + "start": 80057, + "end": 80106 + } + }, + { + "id": "effect_1106", + "effect_id": "effect@80120:80157", + "bound_var": null, + "source_text": "ctx.set_to_extract(931, r925.clone())", + "semantic_text": "to_extract(931) = r925", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r925" + ], + "range": { + "start": 80120, + "end": 80157 + } + }, + { + "id": "effect_1107", + "effect_id": "effect@80182:80227", + "bound_var": "b926", + "source_text": "ctx.insert_t51_mul(b65.clone(), b909.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b65", + "b909" + ], + "range": { + "start": 80182, + "end": 80227 + } + }, + { + "id": "effect_1108", + "effect_id": "effect@80252:80297", + "bound_var": "b927", + "source_text": "ctx.insert_t51_mul(b74.clone(), b913.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b74", + "b913" + ], + "range": { + "start": 80252, + "end": 80297 + } + }, + { + "id": "effect_1109", + "effect_id": "effect@80322:80368", + "bound_var": "b928", + "source_text": "ctx.insert_t51_add(b926.clone(), b927.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b926", + "b927" + ], + "range": { + "start": 80322, + "end": 80368 + } + }, + { + "id": "effect_1110", + "effect_id": "effect@80393:80443", + "bound_var": "b929", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b928.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b928", + "slambda2" + ], + "range": { + "start": 80393, + "end": 80443 + } + }, + { + "id": "effect_1111", + "effect_id": "effect@80468:80514", + "bound_var": "b930", + "source_text": "ctx.insert_t51_add(b918.clone(), b929.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b918", + "b929" + ], + "range": { + "start": 80468, + "end": 80514 + } + }, + { + "id": "effect_1112", + "effect_id": "effect@80539:80589", + "bound_var": "b931", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b930.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b930", + "slambda2" + ], + "range": { + "start": 80539, + "end": 80589 + } + }, + { + "id": "effect_1113", + "effect_id": "effect@80614:80660", + "bound_var": "b932", + "source_text": "ctx.insert_t51_add(b909.clone(), b931.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b909", + "b931" + ], + "range": { + "start": 80614, + "end": 80660 + } + }, + { + "id": "effect_1114", + "effect_id": "effect@80685:80742", + "bound_var": "b933", + "source_text": "ctx.insert_t51_lower(b932.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b932" + ], + "range": { + "start": 80685, + "end": 80742 + } + }, + { + "id": "effect_1115", + "effect_id": "effect@80767:80816", + "bound_var": "r934", + "source_text": "ctx.insert_t51_approx(b324.clone(), b933.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b324", + "b933" + ], + "range": { + "start": 80767, + "end": 80816 + } + }, + { + "id": "effect_1116", + "effect_id": "effect@80830:80867", + "bound_var": null, + "source_text": "ctx.set_to_extract(940, r934.clone())", + "semantic_text": "to_extract(940) = r934", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r934" + ], + "range": { + "start": 80830, + "end": 80867 + } + }, + { + "id": "effect_1117", + "effect_id": "effect@80892:80949", + "bound_var": "b935", + "source_text": "ctx.insert_t51_lower(b354.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b354" + ], + "range": { + "start": 80892, + "end": 80949 + } + }, + { + "id": "effect_1118", + "effect_id": "effect@80974:81023", + "bound_var": "r936", + "source_text": "ctx.insert_t51_approx(b349.clone(), b935.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b349", + "b935" + ], + "range": { + "start": 80974, + "end": 81023 + } + }, + { + "id": "effect_1119", + "effect_id": "effect@81037:81074", + "bound_var": null, + "source_text": "ctx.set_to_extract(942, r936.clone())", + "semantic_text": "to_extract(942) = r936", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r936" + ], + "range": { + "start": 81037, + "end": 81074 + } + }, + { + "id": "effect_1120", + "effect_id": "effect@81099:81146", + "bound_var": "b937", + "source_text": "ctx.insert_t51_add(sphi2.clone(), b899.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b899", + "sphi2" + ], + "range": { + "start": 81099, + "end": 81146 + } + }, + { + "id": "effect_1121", + "effect_id": "effect@81171:81221", + "bound_var": "b938", + "source_text": "ctx.insert_t51_add(slambda1.clone(), b937.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b937", + "slambda1" + ], + "range": { + "start": 81171, + "end": 81221 + } + }, + { + "id": "effect_1122", + "effect_id": "effect@81246:81303", + "bound_var": "b939", + "source_text": "ctx.insert_t51_lower(b938.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b938" + ], + "range": { + "start": 81246, + "end": 81303 + } + }, + { + "id": "effect_1123", + "effect_id": "effect@81328:81377", + "bound_var": "r940", + "source_text": "ctx.insert_t51_approx(b349.clone(), b939.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b349", + "b939" + ], + "range": { + "start": 81328, + "end": 81377 + } + }, + { + "id": "effect_1124", + "effect_id": "effect@81391:81428", + "bound_var": null, + "source_text": "ctx.set_to_extract(946, r940.clone())", + "semantic_text": "to_extract(946) = r940", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r940" + ], + "range": { + "start": 81391, + "end": 81428 + } + }, + { + "id": "effect_1125", + "effect_id": "effect@81453:81485", + "bound_var": "b941", + "source_text": "ctx.insert_t51_sin(b354.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b354" + ], + "range": { + "start": 81453, + "end": 81485 + } + }, + { + "id": "effect_1126", + "effect_id": "effect@81510:81567", + "bound_var": "b942", + "source_text": "ctx.insert_t51_lower(b941.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b941" + ], + "range": { + "start": 81510, + "end": 81567 + } + }, + { + "id": "effect_1127", + "effect_id": "effect@81592:81641", + "bound_var": "r943", + "source_text": "ctx.insert_t51_approx(b358.clone(), b942.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b358", + "b942" + ], + "range": { + "start": 81592, + "end": 81641 + } + }, + { + "id": "effect_1128", + "effect_id": "effect@81655:81692", + "bound_var": null, + "source_text": "ctx.set_to_extract(949, r943.clone())", + "semantic_text": "to_extract(949) = r943", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r943" + ], + "range": { + "start": 81655, + "end": 81692 + } + }, + { + "id": "effect_1129", + "effect_id": "effect@81717:81749", + "bound_var": "b944", + "source_text": "ctx.insert_t51_cos(b354.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b354" + ], + "range": { + "start": 81717, + "end": 81749 + } + }, + { + "id": "effect_1130", + "effect_id": "effect@81774:81824", + "bound_var": "b945", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b944.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b944", + "slambda2" + ], + "range": { + "start": 81774, + "end": 81824 + } + }, + { + "id": "effect_1131", + "effect_id": "effect@81849:81894", + "bound_var": "b946", + "source_text": "ctx.insert_t51_mul(b49.clone(), b945.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b49", + "b945" + ], + "range": { + "start": 81849, + "end": 81894 + } + }, + { + "id": "effect_1132", + "effect_id": "effect@81919:81965", + "bound_var": "b947", + "source_text": "ctx.insert_t51_add(b941.clone(), b946.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b941", + "b946" + ], + "range": { + "start": 81919, + "end": 81965 + } + }, + { + "id": "effect_1133", + "effect_id": "effect@81990:82047", + "bound_var": "b948", + "source_text": "ctx.insert_t51_lower(b947.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b947" + ], + "range": { + "start": 81990, + "end": 82047 + } + }, + { + "id": "effect_1134", + "effect_id": "effect@82072:82121", + "bound_var": "r949", + "source_text": "ctx.insert_t51_approx(b358.clone(), b948.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b358", + "b948" + ], + "range": { + "start": 82072, + "end": 82121 + } + }, + { + "id": "effect_1135", + "effect_id": "effect@82135:82172", + "bound_var": null, + "source_text": "ctx.set_to_extract(955, r949.clone())", + "semantic_text": "to_extract(955) = r949", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r949" + ], + "range": { + "start": 82135, + "end": 82172 + } + }, + { + "id": "effect_1136", + "effect_id": "effect@82197:82242", + "bound_var": "b950", + "source_text": "ctx.insert_t51_mul(b49.clone(), b944.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b49", + "b944" + ], + "range": { + "start": 82197, + "end": 82242 + } + }, + { + "id": "effect_1137", + "effect_id": "effect@82267:82317", + "bound_var": "b951", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b941.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b941", + "slambda2" + ], + "range": { + "start": 82267, + "end": 82317 + } + }, + { + "id": "effect_1138", + "effect_id": "effect@82342:82387", + "bound_var": "b952", + "source_text": "ctx.insert_t51_mul(b65.clone(), b951.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b65", + "b951" + ], + "range": { + "start": 82342, + "end": 82387 + } + }, + { + "id": "effect_1139", + "effect_id": "effect@82412:82458", + "bound_var": "b953", + "source_text": "ctx.insert_t51_add(b950.clone(), b952.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b950", + "b952" + ], + "range": { + "start": 82412, + "end": 82458 + } + }, + { + "id": "effect_1140", + "effect_id": "effect@82483:82533", + "bound_var": "b954", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b953.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b953", + "slambda2" + ], + "range": { + "start": 82483, + "end": 82533 + } + }, + { + "id": "effect_1141", + "effect_id": "effect@82558:82604", + "bound_var": "b955", + "source_text": "ctx.insert_t51_add(b941.clone(), b954.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b941", + "b954" + ], + "range": { + "start": 82558, + "end": 82604 + } + }, + { + "id": "effect_1142", + "effect_id": "effect@82629:82686", + "bound_var": "b956", + "source_text": "ctx.insert_t51_lower(b955.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b955" + ], + "range": { + "start": 82629, + "end": 82686 + } + }, + { + "id": "effect_1143", + "effect_id": "effect@82711:82760", + "bound_var": "r957", + "source_text": "ctx.insert_t51_approx(b358.clone(), b956.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b358", + "b956" + ], + "range": { + "start": 82711, + "end": 82760 + } + }, + { + "id": "effect_1144", + "effect_id": "effect@82774:82811", + "bound_var": null, + "source_text": "ctx.set_to_extract(963, r957.clone())", + "semantic_text": "to_extract(963) = r957", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r957" + ], + "range": { + "start": 82774, + "end": 82811 + } + }, + { + "id": "effect_1145", + "effect_id": "effect@82836:82881", + "bound_var": "b958", + "source_text": "ctx.insert_t51_mul(b65.clone(), b941.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b65", + "b941" + ], + "range": { + "start": 82836, + "end": 82881 + } + }, + { + "id": "effect_1146", + "effect_id": "effect@82906:82951", + "bound_var": "b959", + "source_text": "ctx.insert_t51_mul(b74.clone(), b945.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b74", + "b945" + ], + "range": { + "start": 82906, + "end": 82951 + } + }, + { + "id": "effect_1147", + "effect_id": "effect@82976:83022", + "bound_var": "b960", + "source_text": "ctx.insert_t51_add(b958.clone(), b959.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b958", + "b959" + ], + "range": { + "start": 82976, + "end": 83022 + } + }, + { + "id": "effect_1148", + "effect_id": "effect@83047:83097", + "bound_var": "b961", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b960.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b960", + "slambda2" + ], + "range": { + "start": 83047, + "end": 83097 + } + }, + { + "id": "effect_1149", + "effect_id": "effect@83122:83168", + "bound_var": "b962", + "source_text": "ctx.insert_t51_add(b950.clone(), b961.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b950", + "b961" + ], + "range": { + "start": 83122, + "end": 83168 + } + }, + { + "id": "effect_1150", + "effect_id": "effect@83193:83243", + "bound_var": "b963", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b962.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b962", + "slambda2" + ], + "range": { + "start": 83193, + "end": 83243 + } + }, + { + "id": "effect_1151", + "effect_id": "effect@83268:83314", + "bound_var": "b964", + "source_text": "ctx.insert_t51_add(b941.clone(), b963.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b941", + "b963" + ], + "range": { + "start": 83268, + "end": 83314 + } + }, + { + "id": "effect_1152", + "effect_id": "effect@83339:83396", + "bound_var": "b965", + "source_text": "ctx.insert_t51_lower(b964.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b964" + ], + "range": { + "start": 83339, + "end": 83396 + } + }, + { + "id": "effect_1153", + "effect_id": "effect@83421:83470", + "bound_var": "r966", + "source_text": "ctx.insert_t51_approx(b358.clone(), b965.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b358", + "b965" + ], + "range": { + "start": 83421, + "end": 83470 + } + }, + { + "id": "effect_1154", + "effect_id": "effect@83484:83521", + "bound_var": null, + "source_text": "ctx.set_to_extract(972, r966.clone())", + "semantic_text": "to_extract(972) = r966", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r966" + ], + "range": { + "start": 83484, + "end": 83521 + } + }, + { + "id": "effect_1155", + "effect_id": "effect@83546:83592", + "bound_var": "b967", + "source_text": "ctx.insert_t51_add(b941.clone(), b909.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b909", + "b941" + ], + "range": { + "start": 83546, + "end": 83592 + } + }, + { + "id": "effect_1156", + "effect_id": "effect@83617:83674", + "bound_var": "b968", + "source_text": "ctx.insert_t51_lower(b967.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b967" + ], + "range": { + "start": 83617, + "end": 83674 + } + }, + { + "id": "effect_1157", + "effect_id": "effect@83699:83748", + "bound_var": "r969", + "source_text": "ctx.insert_t51_approx(b383.clone(), b968.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b383", + "b968" + ], + "range": { + "start": 83699, + "end": 83748 + } + }, + { + "id": "effect_1158", + "effect_id": "effect@83762:83799", + "bound_var": null, + "source_text": "ctx.set_to_extract(975, r969.clone())", + "semantic_text": "to_extract(975) = r969", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r969" + ], + "range": { + "start": 83762, + "end": 83799 + } + }, + { + "id": "effect_1159", + "effect_id": "effect@83824:83870", + "bound_var": "b970", + "source_text": "ctx.insert_t51_add(b950.clone(), b918.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b918", + "b950" + ], + "range": { + "start": 83824, + "end": 83870 + } + }, + { + "id": "effect_1160", + "effect_id": "effect@83895:83945", + "bound_var": "b971", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b970.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b970", + "slambda2" + ], + "range": { + "start": 83895, + "end": 83945 + } + }, + { + "id": "effect_1161", + "effect_id": "effect@83970:84016", + "bound_var": "b972", + "source_text": "ctx.insert_t51_add(b909.clone(), b971.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b909", + "b971" + ], + "range": { + "start": 83970, + "end": 84016 + } + }, + { + "id": "effect_1162", + "effect_id": "effect@84041:84087", + "bound_var": "b973", + "source_text": "ctx.insert_t51_add(b941.clone(), b972.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b941", + "b972" + ], + "range": { + "start": 84041, + "end": 84087 + } + }, + { + "id": "effect_1163", + "effect_id": "effect@84112:84169", + "bound_var": "b974", + "source_text": "ctx.insert_t51_lower(b973.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b973" + ], + "range": { + "start": 84112, + "end": 84169 + } + }, + { + "id": "effect_1164", + "effect_id": "effect@84194:84243", + "bound_var": "r975", + "source_text": "ctx.insert_t51_approx(b383.clone(), b974.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b383", + "b974" + ], + "range": { + "start": 84194, + "end": 84243 + } + }, + { + "id": "effect_1165", + "effect_id": "effect@84257:84294", + "bound_var": null, + "source_text": "ctx.set_to_extract(981, r975.clone())", + "semantic_text": "to_extract(981) = r975", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r975" + ], + "range": { + "start": 84257, + "end": 84294 + } + }, + { + "id": "effect_1166", + "effect_id": "effect@84319:84365", + "bound_var": "b976", + "source_text": "ctx.insert_t51_add(b958.clone(), b926.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b926", + "b958" + ], + "range": { + "start": 84319, + "end": 84365 + } + }, + { + "id": "effect_1167", + "effect_id": "effect@84390:84440", + "bound_var": "b977", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b976.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b976", + "slambda2" + ], + "range": { + "start": 84390, + "end": 84440 + } + }, + { + "id": "effect_1168", + "effect_id": "effect@84465:84511", + "bound_var": "b978", + "source_text": "ctx.insert_t51_add(b918.clone(), b977.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b918", + "b977" + ], + "range": { + "start": 84465, + "end": 84511 + } + }, + { + "id": "effect_1169", + "effect_id": "effect@84536:84582", + "bound_var": "b979", + "source_text": "ctx.insert_t51_add(b950.clone(), b978.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b950", + "b978" + ], + "range": { + "start": 84536, + "end": 84582 + } + }, + { + "id": "effect_1170", + "effect_id": "effect@84607:84657", + "bound_var": "b980", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b979.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b979", + "slambda2" + ], + "range": { + "start": 84607, + "end": 84657 + } + }, + { + "id": "effect_1171", + "effect_id": "effect@84682:84728", + "bound_var": "b981", + "source_text": "ctx.insert_t51_add(b909.clone(), b980.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b909", + "b980" + ], + "range": { + "start": 84682, + "end": 84728 + } + }, + { + "id": "effect_1172", + "effect_id": "effect@84753:84799", + "bound_var": "b982", + "source_text": "ctx.insert_t51_add(b941.clone(), b981.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b941", + "b981" + ], + "range": { + "start": 84753, + "end": 84799 + } + }, + { + "id": "effect_1173", + "effect_id": "effect@84824:84881", + "bound_var": "b983", + "source_text": "ctx.insert_t51_lower(b982.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b982" + ], + "range": { + "start": 84824, + "end": 84881 + } + }, + { + "id": "effect_1174", + "effect_id": "effect@84906:84955", + "bound_var": "r984", + "source_text": "ctx.insert_t51_approx(b383.clone(), b983.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b383", + "b983" + ], + "range": { + "start": 84906, + "end": 84955 + } + }, + { + "id": "effect_1175", + "effect_id": "effect@84969:85006", + "bound_var": null, + "source_text": "ctx.set_to_extract(990, r984.clone())", + "semantic_text": "to_extract(990) = r984", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r984" + ], + "range": { + "start": 84969, + "end": 85006 + } + }, + { + "id": "effect_1176", + "effect_id": "effect@85031:85076", + "bound_var": "b985", + "source_text": "ctx.insert_t51_mul(b74.clone(), b944.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b74", + "b944" + ], + "range": { + "start": 85031, + "end": 85076 + } + }, + { + "id": "effect_1177", + "effect_id": "effect@85101:85146", + "bound_var": "b986", + "source_text": "ctx.insert_t51_mul(b74.clone(), b912.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b74", + "b912" + ], + "range": { + "start": 85101, + "end": 85146 + } + }, + { + "id": "effect_1178", + "effect_id": "effect@85171:85217", + "bound_var": "b987", + "source_text": "ctx.insert_t51_add(b985.clone(), b986.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b985", + "b986" + ], + "range": { + "start": 85171, + "end": 85217 + } + }, + { + "id": "effect_1179", + "effect_id": "effect@85242:85292", + "bound_var": "b988", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b987.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b987", + "slambda2" + ], + "range": { + "start": 85242, + "end": 85292 + } + }, + { + "id": "effect_1180", + "effect_id": "effect@85317:85363", + "bound_var": "b989", + "source_text": "ctx.insert_t51_add(b926.clone(), b988.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b926", + "b988" + ], + "range": { + "start": 85317, + "end": 85363 + } + }, + { + "id": "effect_1181", + "effect_id": "effect@85388:85434", + "bound_var": "b990", + "source_text": "ctx.insert_t51_add(b958.clone(), b989.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b958", + "b989" + ], + "range": { + "start": 85388, + "end": 85434 + } + }, + { + "id": "effect_1182", + "effect_id": "effect@85459:85509", + "bound_var": "b991", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b990.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b990", + "slambda2" + ], + "range": { + "start": 85459, + "end": 85509 + } + }, + { + "id": "effect_1183", + "effect_id": "effect@85534:85580", + "bound_var": "b992", + "source_text": "ctx.insert_t51_add(b918.clone(), b991.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b918", + "b991" + ], + "range": { + "start": 85534, + "end": 85580 + } + }, + { + "id": "effect_1184", + "effect_id": "effect@85605:85651", + "bound_var": "b993", + "source_text": "ctx.insert_t51_add(b950.clone(), b992.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b950", + "b992" + ], + "range": { + "start": 85605, + "end": 85651 + } + }, + { + "id": "effect_1185", + "effect_id": "effect@85676:85726", + "bound_var": "b994", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b993.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b993", + "slambda2" + ], + "range": { + "start": 85676, + "end": 85726 + } + }, + { + "id": "effect_1186", + "effect_id": "effect@85751:85797", + "bound_var": "b995", + "source_text": "ctx.insert_t51_add(b909.clone(), b994.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b909", + "b994" + ], + "range": { + "start": 85751, + "end": 85797 + } + }, + { + "id": "effect_1187", + "effect_id": "effect@85822:85868", + "bound_var": "b996", + "source_text": "ctx.insert_t51_add(b941.clone(), b995.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b941", + "b995" + ], + "range": { + "start": 85822, + "end": 85868 + } + }, + { + "id": "effect_1188", + "effect_id": "effect@85893:85950", + "bound_var": "b997", + "source_text": "ctx.insert_t51_lower(b996.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b996" + ], + "range": { + "start": 85893, + "end": 85950 + } + }, + { + "id": "effect_1189", + "effect_id": "effect@85975:86024", + "bound_var": "r998", + "source_text": "ctx.insert_t51_approx(b383.clone(), b997.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b383", + "b997" + ], + "range": { + "start": 85975, + "end": 86024 + } + }, + { + "id": "effect_1190", + "effect_id": "effect@86038:86076", + "bound_var": null, + "source_text": "ctx.set_to_extract(1004, r998.clone())", + "semantic_text": "to_extract(1004) = r998", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r998" + ], + "range": { + "start": 86038, + "end": 86076 + } + }, + { + "id": "effect_1191", + "effect_id": "effect@86101:86146", + "bound_var": "b999", + "source_text": "ctx.insert_t51_mul(b98.clone(), b967.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b967", + "b98" + ], + "range": { + "start": 86101, + "end": 86146 + } + }, + { + "id": "effect_1192", + "effect_id": "effect@86172:86229", + "bound_var": "b1000", + "source_text": "ctx.insert_t51_lower(b999.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b999" + ], + "range": { + "start": 86172, + "end": 86229 + } + }, + { + "id": "effect_1193", + "effect_id": "effect@86255:86305", + "bound_var": "r1001", + "source_text": "ctx.insert_t51_approx(b416.clone(), b1000.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1000", + "b416" + ], + "range": { + "start": 86255, + "end": 86305 + } + }, + { + "id": "effect_1194", + "effect_id": "effect@86319:86358", + "bound_var": null, + "source_text": "ctx.set_to_extract(1007, r1001.clone())", + "semantic_text": "to_extract(1007) = r1001", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1001" + ], + "range": { + "start": 86319, + "end": 86358 + } + }, + { + "id": "effect_1195", + "effect_id": "effect@86384:86429", + "bound_var": "b1002", + "source_text": "ctx.insert_t51_mul(b98.clone(), b971.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b971", + "b98" + ], + "range": { + "start": 86384, + "end": 86429 + } + }, + { + "id": "effect_1196", + "effect_id": "effect@86455:86502", + "bound_var": "b1003", + "source_text": "ctx.insert_t51_add(b1002.clone(), b999.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1002", + "b999" + ], + "range": { + "start": 86455, + "end": 86502 + } + }, + { + "id": "effect_1197", + "effect_id": "effect@86528:86586", + "bound_var": "b1004", + "source_text": "ctx.insert_t51_lower(b1003.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1003" + ], + "range": { + "start": 86528, + "end": 86586 + } + }, + { + "id": "effect_1198", + "effect_id": "effect@86612:86662", + "bound_var": "r1005", + "source_text": "ctx.insert_t51_approx(b416.clone(), b1004.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1004", + "b416" + ], + "range": { + "start": 86612, + "end": 86662 + } + }, + { + "id": "effect_1199", + "effect_id": "effect@86676:86715", + "bound_var": null, + "source_text": "ctx.set_to_extract(1011, r1005.clone())", + "semantic_text": "to_extract(1011) = r1005", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1005" + ], + "range": { + "start": 86676, + "end": 86715 + } + }, + { + "id": "effect_1200", + "effect_id": "effect@86741:86786", + "bound_var": "b1006", + "source_text": "ctx.insert_t51_mul(b98.clone(), b977.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b977", + "b98" + ], + "range": { + "start": 86741, + "end": 86786 + } + }, + { + "id": "effect_1201", + "effect_id": "effect@86812:86857", + "bound_var": "b1007", + "source_text": "ctx.insert_t51_mul(b98.clone(), b970.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b970", + "b98" + ], + "range": { + "start": 86812, + "end": 86857 + } + }, + { + "id": "effect_1202", + "effect_id": "effect@86883:86931", + "bound_var": "b1008", + "source_text": "ctx.insert_t51_add(b1006.clone(), b1007.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1006", + "b1007" + ], + "range": { + "start": 86883, + "end": 86931 + } + }, + { + "id": "effect_1203", + "effect_id": "effect@86957:87008", + "bound_var": "b1009", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b1008.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1008", + "slambda2" + ], + "range": { + "start": 86957, + "end": 87008 + } + }, + { + "id": "effect_1204", + "effect_id": "effect@87034:87081", + "bound_var": "b1010", + "source_text": "ctx.insert_t51_add(b999.clone(), b1009.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1009", + "b999" + ], + "range": { + "start": 87034, + "end": 87081 + } + }, + { + "id": "effect_1205", + "effect_id": "effect@87107:87165", + "bound_var": "b1011", + "source_text": "ctx.insert_t51_lower(b1010.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1010" + ], + "range": { + "start": 87107, + "end": 87165 + } + }, + { + "id": "effect_1206", + "effect_id": "effect@87191:87241", + "bound_var": "r1012", + "source_text": "ctx.insert_t51_approx(b416.clone(), b1011.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1011", + "b416" + ], + "range": { + "start": 87191, + "end": 87241 + } + }, + { + "id": "effect_1207", + "effect_id": "effect@87255:87294", + "bound_var": null, + "source_text": "ctx.set_to_extract(1018, r1012.clone())", + "semantic_text": "to_extract(1018) = r1012", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1012" + ], + "range": { + "start": 87255, + "end": 87294 + } + }, + { + "id": "effect_1208", + "effect_id": "effect@87320:87365", + "bound_var": "b1013", + "source_text": "ctx.insert_t51_mul(b98.clone(), b988.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b98", + "b988" + ], + "range": { + "start": 87320, + "end": 87365 + } + }, + { + "id": "effect_1209", + "effect_id": "effect@87391:87436", + "bound_var": "b1014", + "source_text": "ctx.insert_t51_mul(b98.clone(), b976.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b976", + "b98" + ], + "range": { + "start": 87391, + "end": 87436 + } + }, + { + "id": "effect_1210", + "effect_id": "effect@87462:87510", + "bound_var": "b1015", + "source_text": "ctx.insert_t51_add(b1013.clone(), b1014.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1013", + "b1014" + ], + "range": { + "start": 87462, + "end": 87510 + } + }, + { + "id": "effect_1211", + "effect_id": "effect@87536:87587", + "bound_var": "b1016", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b1015.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1015", + "slambda2" + ], + "range": { + "start": 87536, + "end": 87587 + } + }, + { + "id": "effect_1212", + "effect_id": "effect@87613:87661", + "bound_var": "b1017", + "source_text": "ctx.insert_t51_add(b1007.clone(), b1016.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1007", + "b1016" + ], + "range": { + "start": 87613, + "end": 87661 + } + }, + { + "id": "effect_1213", + "effect_id": "effect@87687:87738", + "bound_var": "b1018", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b1017.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1017", + "slambda2" + ], + "range": { + "start": 87687, + "end": 87738 + } + }, + { + "id": "effect_1214", + "effect_id": "effect@87764:87811", + "bound_var": "b1019", + "source_text": "ctx.insert_t51_add(b999.clone(), b1018.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1018", + "b999" + ], + "range": { + "start": 87764, + "end": 87811 + } + }, + { + "id": "effect_1215", + "effect_id": "effect@87837:87895", + "bound_var": "b1020", + "source_text": "ctx.insert_t51_lower(b1019.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1019" + ], + "range": { + "start": 87837, + "end": 87895 + } + }, + { + "id": "effect_1216", + "effect_id": "effect@87921:87971", + "bound_var": "r1021", + "source_text": "ctx.insert_t51_approx(b416.clone(), b1020.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1020", + "b416" + ], + "range": { + "start": 87921, + "end": 87971 + } + }, + { + "id": "effect_1217", + "effect_id": "effect@87985:88024", + "bound_var": null, + "source_text": "ctx.set_to_extract(1027, r1021.clone())", + "semantic_text": "to_extract(1027) = r1021", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1021" + ], + "range": { + "start": 87985, + "end": 88024 + } + }, + { + "id": "effect_1218", + "effect_id": "effect@88050:88096", + "bound_var": "b1022", + "source_text": "ctx.insert_t51_add(b999.clone(), b279.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b279", + "b999" + ], + "range": { + "start": 88050, + "end": 88096 + } + }, + { + "id": "effect_1219", + "effect_id": "effect@88122:88180", + "bound_var": "b1023", + "source_text": "ctx.insert_t51_lower(b1022.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1022" + ], + "range": { + "start": 88122, + "end": 88180 + } + }, + { + "id": "effect_1220", + "effect_id": "effect@88206:88256", + "bound_var": "r1024", + "source_text": "ctx.insert_t51_approx(b440.clone(), b1023.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1023", + "b440" + ], + "range": { + "start": 88206, + "end": 88256 + } + }, + { + "id": "effect_1221", + "effect_id": "effect@88270:88309", + "bound_var": null, + "source_text": "ctx.set_to_extract(1030, r1024.clone())", + "semantic_text": "to_extract(1030) = r1024", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1024" + ], + "range": { + "start": 88270, + "end": 88309 + } + }, + { + "id": "effect_1222", + "effect_id": "effect@88335:88383", + "bound_var": "b1025", + "source_text": "ctx.insert_t51_add(b1002.clone(), b1022.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1002", + "b1022" + ], + "range": { + "start": 88335, + "end": 88383 + } + }, + { + "id": "effect_1223", + "effect_id": "effect@88409:88467", + "bound_var": "b1026", + "source_text": "ctx.insert_t51_lower(b1025.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1025" + ], + "range": { + "start": 88409, + "end": 88467 + } + }, + { + "id": "effect_1224", + "effect_id": "effect@88493:88543", + "bound_var": "r1027", + "source_text": "ctx.insert_t51_approx(b440.clone(), b1026.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1026", + "b440" + ], + "range": { + "start": 88493, + "end": 88543 + } + }, + { + "id": "effect_1225", + "effect_id": "effect@88557:88596", + "bound_var": null, + "source_text": "ctx.set_to_extract(1033, r1027.clone())", + "semantic_text": "to_extract(1033) = r1027", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1027" + ], + "range": { + "start": 88557, + "end": 88596 + } + }, + { + "id": "effect_1226", + "effect_id": "effect@88622:88669", + "bound_var": "b1028", + "source_text": "ctx.insert_t51_add(b1009.clone(), b279.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1009", + "b279" + ], + "range": { + "start": 88622, + "end": 88669 + } + }, + { + "id": "effect_1227", + "effect_id": "effect@88695:88742", + "bound_var": "b1029", + "source_text": "ctx.insert_t51_add(b999.clone(), b1028.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1028", + "b999" + ], + "range": { + "start": 88695, + "end": 88742 + } + }, + { + "id": "effect_1228", + "effect_id": "effect@88768:88826", + "bound_var": "b1030", + "source_text": "ctx.insert_t51_lower(b1029.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1029" + ], + "range": { + "start": 88768, + "end": 88826 + } + }, + { + "id": "effect_1229", + "effect_id": "effect@88852:88902", + "bound_var": "r1031", + "source_text": "ctx.insert_t51_approx(b440.clone(), b1030.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1030", + "b440" + ], + "range": { + "start": 88852, + "end": 88902 + } + }, + { + "id": "effect_1230", + "effect_id": "effect@88916:88955", + "bound_var": null, + "source_text": "ctx.set_to_extract(1037, r1031.clone())", + "semantic_text": "to_extract(1037) = r1031", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1031" + ], + "range": { + "start": 88916, + "end": 88955 + } + }, + { + "id": "effect_1231", + "effect_id": "effect@88981:89028", + "bound_var": "b1032", + "source_text": "ctx.insert_t51_add(b1018.clone(), b279.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1018", + "b279" + ], + "range": { + "start": 88981, + "end": 89028 + } + }, + { + "id": "effect_1232", + "effect_id": "effect@89054:89101", + "bound_var": "b1033", + "source_text": "ctx.insert_t51_add(b999.clone(), b1032.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1032", + "b999" + ], + "range": { + "start": 89054, + "end": 89101 + } + }, + { + "id": "effect_1233", + "effect_id": "effect@89127:89185", + "bound_var": "b1034", + "source_text": "ctx.insert_t51_lower(b1033.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1033" + ], + "range": { + "start": 89127, + "end": 89185 + } + }, + { + "id": "effect_1234", + "effect_id": "effect@89211:89261", + "bound_var": "r1035", + "source_text": "ctx.insert_t51_approx(b440.clone(), b1034.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1034", + "b440" + ], + "range": { + "start": 89211, + "end": 89261 + } + }, + { + "id": "effect_1235", + "effect_id": "effect@89275:89314", + "bound_var": null, + "source_text": "ctx.set_to_extract(1041, r1035.clone())", + "semantic_text": "to_extract(1041) = r1035", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1035" + ], + "range": { + "start": 89275, + "end": 89314 + } + }, + { + "id": "effect_1236", + "effect_id": "effect@89340:89394", + "bound_var": "b1036", + "source_text": "ctx.insert_t51_div(slambda1.clone(), slambda2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "slambda1", + "slambda2" + ], + "range": { + "start": 89340, + "end": 89394 + } + }, + { + "id": "effect_1237", + "effect_id": "effect@89420:89466", + "bound_var": "b1037", + "source_text": "ctx.insert_t51_sub(b1036.clone(), b87.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1036", + "b87" + ], + "range": { + "start": 89420, + "end": 89466 + } + }, + { + "id": "effect_1238", + "effect_id": "effect@89492:89543", + "bound_var": "b1038", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b1037.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1037", + "slambda2" + ], + "range": { + "start": 89492, + "end": 89543 + } + }, + { + "id": "effect_1239", + "effect_id": "effect@89569:89627", + "bound_var": "b1039", + "source_text": "ctx.insert_t51_lower(b1038.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1038" + ], + "range": { + "start": 89569, + "end": 89627 + } + }, + { + "id": "effect_1240", + "effect_id": "effect@89653:89702", + "bound_var": "r1040", + "source_text": "ctx.insert_t51_approx(b16.clone(), b1039.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1039", + "b16" + ], + "range": { + "start": 89653, + "end": 89702 + } + }, + { + "id": "effect_1241", + "effect_id": "effect@89716:89755", + "bound_var": null, + "source_text": "ctx.set_to_extract(1046, r1040.clone())", + "semantic_text": "to_extract(1046) = r1040", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1040" + ], + "range": { + "start": 89716, + "end": 89755 + } + }, + { + "id": "effect_1242", + "effect_id": "effect@89781:89837", + "bound_var": "b1041", + "source_text": "ctx.insert_t51_lower(b59.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b59" + ], + "range": { + "start": 89781, + "end": 89837 + } + }, + { + "id": "effect_1243", + "effect_id": "effect@89863:89912", + "bound_var": "r1042", + "source_text": "ctx.insert_t51_approx(b59.clone(), b1041.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1041", + "b59" + ], + "range": { + "start": 89863, + "end": 89912 + } + }, + { + "id": "effect_1244", + "effect_id": "effect@89926:89965", + "bound_var": null, + "source_text": "ctx.set_to_extract(1048, r1042.clone())", + "semantic_text": "to_extract(1048) = r1042", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1042" + ], + "range": { + "start": 89926, + "end": 89965 + } + }, + { + "id": "effect_1245", + "effect_id": "effect@89991:90047", + "bound_var": "b1043", + "source_text": "ctx.insert_t51_lower(b33.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b33" + ], + "range": { + "start": 89991, + "end": 90047 + } + }, + { + "id": "effect_1246", + "effect_id": "effect@90073:90122", + "bound_var": "r1044", + "source_text": "ctx.insert_t51_approx(b33.clone(), b1043.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1043", + "b33" + ], + "range": { + "start": 90073, + "end": 90122 + } + }, + { + "id": "effect_1247", + "effect_id": "effect@90136:90175", + "bound_var": null, + "source_text": "ctx.set_to_extract(1050, r1044.clone())", + "semantic_text": "to_extract(1050) = r1044", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1044" + ], + "range": { + "start": 90136, + "end": 90175 + } + }, + { + "id": "effect_1248", + "effect_id": "effect@90201:90251", + "bound_var": "b1045", + "source_text": "ctx.insert_t51_div(b306.clone(), slambda2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b306", + "slambda2" + ], + "range": { + "start": 90201, + "end": 90251 + } + }, + { + "id": "effect_1249", + "effect_id": "effect@90277:90323", + "bound_var": "b1046", + "source_text": "ctx.insert_t51_mul(b98.clone(), b1045.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1045", + "b98" + ], + "range": { + "start": 90277, + "end": 90323 + } + }, + { + "id": "effect_1250", + "effect_id": "effect@90349:90397", + "bound_var": "b1047", + "source_text": "ctx.insert_t51_add(b1046.clone(), b1036.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1036", + "b1046" + ], + "range": { + "start": 90349, + "end": 90397 + } + }, + { + "id": "effect_1251", + "effect_id": "effect@90423:90469", + "bound_var": "b1048", + "source_text": "ctx.insert_t51_sub(b1047.clone(), b87.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1047", + "b87" + ], + "range": { + "start": 90423, + "end": 90469 + } + }, + { + "id": "effect_1252", + "effect_id": "effect@90495:90546", + "bound_var": "b1049", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b1048.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1048", + "slambda2" + ], + "range": { + "start": 90495, + "end": 90546 + } + }, + { + "id": "effect_1253", + "effect_id": "effect@90572:90630", + "bound_var": "b1050", + "source_text": "ctx.insert_t51_lower(b1049.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1049" + ], + "range": { + "start": 90572, + "end": 90630 + } + }, + { + "id": "effect_1254", + "effect_id": "effect@90656:90706", + "bound_var": "r1051", + "source_text": "ctx.insert_t51_approx(b308.clone(), b1050.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1050", + "b308" + ], + "range": { + "start": 90656, + "end": 90706 + } + }, + { + "id": "effect_1255", + "effect_id": "effect@90720:90759", + "bound_var": null, + "source_text": "ctx.set_to_extract(1057, r1051.clone())", + "semantic_text": "to_extract(1057) = r1051", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1051" + ], + "range": { + "start": 90720, + "end": 90759 + } + }, + { + "id": "effect_1256", + "effect_id": "effect@90785:90836", + "bound_var": "b1052", + "source_text": "ctx.insert_t51_div(sphi2.clone(), slambda2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "slambda2", + "sphi2" + ], + "range": { + "start": 90785, + "end": 90836 + } + }, + { + "id": "effect_1257", + "effect_id": "effect@90862:90908", + "bound_var": "b1053", + "source_text": "ctx.insert_t51_add(b87.clone(), b1052.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1052", + "b87" + ], + "range": { + "start": 90862, + "end": 90908 + } + }, + { + "id": "effect_1258", + "effect_id": "effect@90934:90982", + "bound_var": "b1054", + "source_text": "ctx.insert_t51_sub(b1047.clone(), b1053.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1047", + "b1053" + ], + "range": { + "start": 90934, + "end": 90982 + } + }, + { + "id": "effect_1259", + "effect_id": "effect@91008:91059", + "bound_var": "b1055", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b1054.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1054", + "slambda2" + ], + "range": { + "start": 91008, + "end": 91059 + } + }, + { + "id": "effect_1260", + "effect_id": "effect@91085:91143", + "bound_var": "b1056", + "source_text": "ctx.insert_t51_lower(b1055.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1055" + ], + "range": { + "start": 91085, + "end": 91143 + } + }, + { + "id": "effect_1261", + "effect_id": "effect@91169:91219", + "bound_var": "r1057", + "source_text": "ctx.insert_t51_approx(b316.clone(), b1056.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1056", + "b316" + ], + "range": { + "start": 91169, + "end": 91219 + } + }, + { + "id": "effect_1262", + "effect_id": "effect@91233:91272", + "bound_var": null, + "source_text": "ctx.set_to_extract(1063, r1057.clone())", + "semantic_text": "to_extract(1063) = r1057", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1057" + ], + "range": { + "start": 91233, + "end": 91272 + } + }, + { + "id": "effect_1263", + "effect_id": "effect@91298:91346", + "bound_var": "b1058", + "source_text": "ctx.insert_t51_add(b1036.clone(), b1052.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1036", + "b1052" + ], + "range": { + "start": 91298, + "end": 91346 + } + }, + { + "id": "effect_1264", + "effect_id": "effect@91372:91420", + "bound_var": "b1059", + "source_text": "ctx.insert_t51_add(b1046.clone(), b1058.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1046", + "b1058" + ], + "range": { + "start": 91372, + "end": 91420 + } + }, + { + "id": "effect_1265", + "effect_id": "effect@91446:91492", + "bound_var": "b1060", + "source_text": "ctx.insert_t51_sub(b1059.clone(), b87.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1059", + "b87" + ], + "range": { + "start": 91446, + "end": 91492 + } + }, + { + "id": "effect_1266", + "effect_id": "effect@91518:91569", + "bound_var": "b1061", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b1060.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1060", + "slambda2" + ], + "range": { + "start": 91518, + "end": 91569 + } + }, + { + "id": "effect_1267", + "effect_id": "effect@91595:91653", + "bound_var": "b1062", + "source_text": "ctx.insert_t51_lower(b1061.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1061" + ], + "range": { + "start": 91595, + "end": 91653 + } + }, + { + "id": "effect_1268", + "effect_id": "effect@91679:91729", + "bound_var": "r1063", + "source_text": "ctx.insert_t51_approx(b349.clone(), b1062.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1062", + "b349" + ], + "range": { + "start": 91679, + "end": 91729 + } + }, + { + "id": "effect_1269", + "effect_id": "effect@91743:91782", + "bound_var": null, + "source_text": "ctx.set_to_extract(1069, r1063.clone())", + "semantic_text": "to_extract(1069) = r1063", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1063" + ], + "range": { + "start": 91743, + "end": 91782 + } + }, + { + "id": "effect_1270", + "effect_id": "effect@91808:91854", + "bound_var": "b1064", + "source_text": "ctx.insert_t51_mul(b49.clone(), b1036.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1036", + "b49" + ], + "range": { + "start": 91808, + "end": 91854 + } + }, + { + "id": "effect_1271", + "effect_id": "effect@91880:91926", + "bound_var": "b1065", + "source_text": "ctx.insert_t51_add(b87.clone(), b1064.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1064", + "b87" + ], + "range": { + "start": 91880, + "end": 91926 + } + }, + { + "id": "effect_1272", + "effect_id": "effect@91952:92003", + "bound_var": "b1066", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b1065.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1065", + "slambda2" + ], + "range": { + "start": 91952, + "end": 92003 + } + }, + { + "id": "effect_1273", + "effect_id": "effect@92029:92075", + "bound_var": "b1067", + "source_text": "ctx.insert_t51_mul(b49.clone(), b1066.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1066", + "b49" + ], + "range": { + "start": 92029, + "end": 92075 + } + }, + { + "id": "effect_1274", + "effect_id": "effect@92101:92159", + "bound_var": "b1068", + "source_text": "ctx.insert_t51_lower(b1067.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1067" + ], + "range": { + "start": 92101, + "end": 92159 + } + }, + { + "id": "effect_1275", + "effect_id": "effect@92185:92234", + "bound_var": "r1069", + "source_text": "ctx.insert_t51_approx(b16.clone(), b1068.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1068", + "b16" + ], + "range": { + "start": 92185, + "end": 92234 + } + }, + { + "id": "effect_1276", + "effect_id": "effect@92248:92287", + "bound_var": null, + "source_text": "ctx.set_to_extract(1075, r1069.clone())", + "semantic_text": "to_extract(1075) = r1069", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1069" + ], + "range": { + "start": 92248, + "end": 92287 + } + }, + { + "id": "effect_1277", + "effect_id": "effect@92313:92345", + "bound_var": "b1070", + "source_text": "ctx.insert_t51_cos(b617.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b617" + ], + "range": { + "start": 92313, + "end": 92345 + } + }, + { + "id": "effect_1278", + "effect_id": "effect@92371:92429", + "bound_var": "b1071", + "source_text": "ctx.insert_t51_lower(b1070.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1070" + ], + "range": { + "start": 92371, + "end": 92429 + } + }, + { + "id": "effect_1279", + "effect_id": "effect@92455:92504", + "bound_var": "r1072", + "source_text": "ctx.insert_t51_approx(b17.clone(), b1071.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1071", + "b17" + ], + "range": { + "start": 92455, + "end": 92504 + } + }, + { + "id": "effect_1280", + "effect_id": "effect@92518:92557", + "bound_var": null, + "source_text": "ctx.set_to_extract(1078, r1072.clone())", + "semantic_text": "to_extract(1078) = r1072", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1072" + ], + "range": { + "start": 92518, + "end": 92557 + } + }, + { + "id": "effect_1281", + "effect_id": "effect@92583:92614", + "bound_var": "b1073", + "source_text": "ctx.insert_t51_cos(b50.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b50" + ], + "range": { + "start": 92583, + "end": 92614 + } + }, + { + "id": "effect_1282", + "effect_id": "effect@92640:92698", + "bound_var": "b1074", + "source_text": "ctx.insert_t51_lower(b1073.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1073" + ], + "range": { + "start": 92640, + "end": 92698 + } + }, + { + "id": "effect_1283", + "effect_id": "effect@92724:92773", + "bound_var": "r1075", + "source_text": "ctx.insert_t51_approx(b56.clone(), b1074.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1074", + "b56" + ], + "range": { + "start": 92724, + "end": 92773 + } + }, + { + "id": "effect_1284", + "effect_id": "effect@92787:92826", + "bound_var": null, + "source_text": "ctx.set_to_extract(1081, r1075.clone())", + "semantic_text": "to_extract(1081) = r1075", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1075" + ], + "range": { + "start": 92787, + "end": 92826 + } + }, + { + "id": "effect_1285", + "effect_id": "effect@92852:92883", + "bound_var": "b1076", + "source_text": "ctx.insert_t51_sin(b50.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b50" + ], + "range": { + "start": 92852, + "end": 92883 + } + }, + { + "id": "effect_1286", + "effect_id": "effect@92909:92967", + "bound_var": "b1077", + "source_text": "ctx.insert_t51_lower(b1076.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1076" + ], + "range": { + "start": 92909, + "end": 92967 + } + }, + { + "id": "effect_1287", + "effect_id": "effect@92993:93042", + "bound_var": "r1078", + "source_text": "ctx.insert_t51_approx(b59.clone(), b1077.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1077", + "b59" + ], + "range": { + "start": 92993, + "end": 93042 + } + }, + { + "id": "effect_1288", + "effect_id": "effect@93056:93095", + "bound_var": null, + "source_text": "ctx.set_to_extract(1084, r1078.clone())", + "semantic_text": "to_extract(1084) = r1078", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1078" + ], + "range": { + "start": 93056, + "end": 93095 + } + }, + { + "id": "effect_1289", + "effect_id": "effect@93121:93172", + "bound_var": "b1079", + "source_text": "ctx.insert_t51_mul(slambda1.clone(), b1076.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1076", + "slambda1" + ], + "range": { + "start": 93121, + "end": 93172 + } + }, + { + "id": "effect_1290", + "effect_id": "effect@93198:93256", + "bound_var": "b1080", + "source_text": "ctx.insert_t51_lower(b1079.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1079" + ], + "range": { + "start": 93198, + "end": 93256 + } + }, + { + "id": "effect_1291", + "effect_id": "effect@93282:93331", + "bound_var": "r1081", + "source_text": "ctx.insert_t51_approx(b60.clone(), b1080.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1080", + "b60" + ], + "range": { + "start": 93282, + "end": 93331 + } + }, + { + "id": "effect_1292", + "effect_id": "effect@93345:93384", + "bound_var": null, + "source_text": "ctx.set_to_extract(1087, r1081.clone())", + "semantic_text": "to_extract(1087) = r1081", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1081" + ], + "range": { + "start": 93345, + "end": 93384 + } + }, + { + "id": "effect_1293", + "effect_id": "effect@93410:93456", + "bound_var": "b1082", + "source_text": "ctx.insert_t51_mul(b49.clone(), b1079.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1079", + "b49" + ], + "range": { + "start": 93410, + "end": 93456 + } + }, + { + "id": "effect_1294", + "effect_id": "effect@93482:93540", + "bound_var": "b1083", + "source_text": "ctx.insert_t51_lower(b1082.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1082" + ], + "range": { + "start": 93482, + "end": 93540 + } + }, + { + "id": "effect_1295", + "effect_id": "effect@93566:93615", + "bound_var": "r1084", + "source_text": "ctx.insert_t51_approx(b61.clone(), b1083.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1083", + "b61" + ], + "range": { + "start": 93566, + "end": 93615 + } + }, + { + "id": "effect_1296", + "effect_id": "effect@93629:93668", + "bound_var": null, + "source_text": "ctx.set_to_extract(1090, r1084.clone())", + "semantic_text": "to_extract(1090) = r1084", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1084" + ], + "range": { + "start": 93629, + "end": 93668 + } + }, + { + "id": "effect_1297", + "effect_id": "effect@93694:93742", + "bound_var": "b1085", + "source_text": "ctx.insert_t51_add(b1073.clone(), b1082.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1073", + "b1082" + ], + "range": { + "start": 93694, + "end": 93742 + } + }, + { + "id": "effect_1298", + "effect_id": "effect@93768:93826", + "bound_var": "b1086", + "source_text": "ctx.insert_t51_lower(b1085.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1085" + ], + "range": { + "start": 93768, + "end": 93826 + } + }, + { + "id": "effect_1299", + "effect_id": "effect@93852:93901", + "bound_var": "r1087", + "source_text": "ctx.insert_t51_approx(b62.clone(), b1086.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1086", + "b62" + ], + "range": { + "start": 93852, + "end": 93901 + } + }, + { + "id": "effect_1300", + "effect_id": "effect@93915:93954", + "bound_var": null, + "source_text": "ctx.set_to_extract(1093, r1087.clone())", + "semantic_text": "to_extract(1093) = r1087", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1087" + ], + "range": { + "start": 93915, + "end": 93954 + } + }, + { + "id": "effect_1301", + "effect_id": "effect@93980:94026", + "bound_var": "b1088", + "source_text": "ctx.insert_t51_mul(b12.clone(), b1070.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1070", + "b12" + ], + "range": { + "start": 93980, + "end": 94026 + } + }, + { + "id": "effect_1302", + "effect_id": "effect@94052:94098", + "bound_var": "b1089", + "source_text": "ctx.insert_t51_mul(b11.clone(), b1088.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1088", + "b11" + ], + "range": { + "start": 94052, + "end": 94098 + } + }, + { + "id": "effect_1303", + "effect_id": "effect@94124:94182", + "bound_var": "b1090", + "source_text": "ctx.insert_t51_lower(b1089.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1089" + ], + "range": { + "start": 94124, + "end": 94182 + } + }, + { + "id": "effect_1304", + "effect_id": "effect@94208:94257", + "bound_var": "r1091", + "source_text": "ctx.insert_t51_approx(b18.clone(), b1090.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1090", + "b18" + ], + "range": { + "start": 94208, + "end": 94257 + } + }, + { + "id": "effect_1305", + "effect_id": "effect@94271:94310", + "bound_var": null, + "source_text": "ctx.set_to_extract(1097, r1091.clone())", + "semantic_text": "to_extract(1097) = r1091", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1091" + ], + "range": { + "start": 94271, + "end": 94310 + } + }, + { + "id": "effect_1306", + "effect_id": "effect@94336:94383", + "bound_var": "b1092", + "source_text": "ctx.insert_t51_add(b1070.clone(), b262.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1070", + "b262" + ], + "range": { + "start": 94336, + "end": 94383 + } + }, + { + "id": "effect_1307", + "effect_id": "effect@94409:94467", + "bound_var": "b1093", + "source_text": "ctx.insert_t51_lower(b1092.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1092" + ], + "range": { + "start": 94409, + "end": 94467 + } + }, + { + "id": "effect_1308", + "effect_id": "effect@94493:94543", + "bound_var": "r1094", + "source_text": "ctx.insert_t51_approx(b263.clone(), b1093.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1093", + "b263" + ], + "range": { + "start": 94493, + "end": 94543 + } + }, + { + "id": "effect_1309", + "effect_id": "effect@94557:94596", + "bound_var": null, + "source_text": "ctx.set_to_extract(1100, r1094.clone())", + "semantic_text": "to_extract(1100) = r1094", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1094" + ], + "range": { + "start": 94557, + "end": 94596 + } + }, + { + "id": "effect_1310", + "effect_id": "effect@94622:94669", + "bound_var": "b1095", + "source_text": "ctx.insert_t51_add(b279.clone(), b1088.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1088", + "b279" + ], + "range": { + "start": 94622, + "end": 94669 + } + }, + { + "id": "effect_1311", + "effect_id": "effect@94695:94753", + "bound_var": "b1096", + "source_text": "ctx.insert_t51_lower(b1095.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1095" + ], + "range": { + "start": 94695, + "end": 94753 + } + }, + { + "id": "effect_1312", + "effect_id": "effect@94779:94829", + "bound_var": "r1097", + "source_text": "ctx.insert_t51_approx(b280.clone(), b1096.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1096", + "b280" + ], + "range": { + "start": 94779, + "end": 94829 + } + }, + { + "id": "effect_1313", + "effect_id": "effect@94843:94882", + "bound_var": null, + "source_text": "ctx.set_to_extract(1103, r1097.clone())", + "semantic_text": "to_extract(1103) = r1097", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1097" + ], + "range": { + "start": 94843, + "end": 94882 + } + }, + { + "id": "effect_1314", + "effect_id": "effect@94908:94958", + "bound_var": "b1098", + "source_text": "ctx.insert_t51_div(b312.clone(), slambda2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b312", + "slambda2" + ], + "range": { + "start": 94908, + "end": 94958 + } + }, + { + "id": "effect_1315", + "effect_id": "effect@94984:95030", + "bound_var": "b1099", + "source_text": "ctx.insert_t51_mul(b49.clone(), b1098.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1098", + "b49" + ], + "range": { + "start": 94984, + "end": 95030 + } + }, + { + "id": "effect_1316", + "effect_id": "effect@95056:95102", + "bound_var": "b1100", + "source_text": "ctx.insert_t51_add(b87.clone(), b1099.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1099", + "b87" + ], + "range": { + "start": 95056, + "end": 95102 + } + }, + { + "id": "effect_1317", + "effect_id": "effect@95128:95179", + "bound_var": "b1101", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b1100.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1100", + "slambda2" + ], + "range": { + "start": 95128, + "end": 95179 + } + }, + { + "id": "effect_1318", + "effect_id": "effect@95205:95251", + "bound_var": "b1102", + "source_text": "ctx.insert_t51_mul(b49.clone(), b1101.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1101", + "b49" + ], + "range": { + "start": 95205, + "end": 95251 + } + }, + { + "id": "effect_1319", + "effect_id": "effect@95277:95335", + "bound_var": "b1103", + "source_text": "ctx.insert_t51_lower(b1102.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1102" + ], + "range": { + "start": 95277, + "end": 95335 + } + }, + { + "id": "effect_1320", + "effect_id": "effect@95361:95411", + "bound_var": "r1104", + "source_text": "ctx.insert_t51_approx(b308.clone(), b1103.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1103", + "b308" + ], + "range": { + "start": 95361, + "end": 95411 + } + }, + { + "id": "effect_1321", + "effect_id": "effect@95425:95464", + "bound_var": null, + "source_text": "ctx.set_to_extract(1110, r1104.clone())", + "semantic_text": "to_extract(1110) = r1104", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1104" + ], + "range": { + "start": 95425, + "end": 95464 + } + }, + { + "id": "effect_1322", + "effect_id": "effect@95490:95540", + "bound_var": "b1105", + "source_text": "ctx.insert_t51_div(b903.clone(), slambda2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b903", + "slambda2" + ], + "range": { + "start": 95490, + "end": 95540 + } + }, + { + "id": "effect_1323", + "effect_id": "effect@95566:95612", + "bound_var": "b1106", + "source_text": "ctx.insert_t51_mul(b49.clone(), b1105.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1105", + "b49" + ], + "range": { + "start": 95566, + "end": 95612 + } + }, + { + "id": "effect_1324", + "effect_id": "effect@95638:95684", + "bound_var": "b1107", + "source_text": "ctx.insert_t51_add(b87.clone(), b1106.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1106", + "b87" + ], + "range": { + "start": 95638, + "end": 95684 + } + }, + { + "id": "effect_1325", + "effect_id": "effect@95710:95761", + "bound_var": "b1108", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b1107.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1107", + "slambda2" + ], + "range": { + "start": 95710, + "end": 95761 + } + }, + { + "id": "effect_1326", + "effect_id": "effect@95787:95833", + "bound_var": "b1109", + "source_text": "ctx.insert_t51_mul(b49.clone(), b1108.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1108", + "b49" + ], + "range": { + "start": 95787, + "end": 95833 + } + }, + { + "id": "effect_1327", + "effect_id": "effect@95859:95917", + "bound_var": "b1110", + "source_text": "ctx.insert_t51_lower(b1109.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1109" + ], + "range": { + "start": 95859, + "end": 95917 + } + }, + { + "id": "effect_1328", + "effect_id": "effect@95943:95993", + "bound_var": "r1111", + "source_text": "ctx.insert_t51_approx(b316.clone(), b1110.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1110", + "b316" + ], + "range": { + "start": 95943, + "end": 95993 + } + }, + { + "id": "effect_1329", + "effect_id": "effect@96007:96046", + "bound_var": null, + "source_text": "ctx.set_to_extract(1117, r1111.clone())", + "semantic_text": "to_extract(1117) = r1111", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1111" + ], + "range": { + "start": 96007, + "end": 96046 + } + }, + { + "id": "effect_1330", + "effect_id": "effect@96072:96104", + "bound_var": "b1112", + "source_text": "ctx.insert_t51_sin(b906.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b906" + ], + "range": { + "start": 96072, + "end": 96104 + } + }, + { + "id": "effect_1331", + "effect_id": "effect@96130:96188", + "bound_var": "b1113", + "source_text": "ctx.insert_t51_lower(b1112.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1112" + ], + "range": { + "start": 96130, + "end": 96188 + } + }, + { + "id": "effect_1332", + "effect_id": "effect@96214:96264", + "bound_var": "r1114", + "source_text": "ctx.insert_t51_approx(b324.clone(), b1113.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1113", + "b324" + ], + "range": { + "start": 96214, + "end": 96264 + } + }, + { + "id": "effect_1333", + "effect_id": "effect@96278:96317", + "bound_var": null, + "source_text": "ctx.set_to_extract(1120, r1114.clone())", + "semantic_text": "to_extract(1120) = r1114", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1114" + ], + "range": { + "start": 96278, + "end": 96317 + } + }, + { + "id": "effect_1334", + "effect_id": "effect@96343:96393", + "bound_var": "b1115", + "source_text": "ctx.insert_t51_div(b354.clone(), slambda2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b354", + "slambda2" + ], + "range": { + "start": 96343, + "end": 96393 + } + }, + { + "id": "effect_1335", + "effect_id": "effect@96419:96465", + "bound_var": "b1116", + "source_text": "ctx.insert_t51_mul(b49.clone(), b1115.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1115", + "b49" + ], + "range": { + "start": 96419, + "end": 96465 + } + }, + { + "id": "effect_1336", + "effect_id": "effect@96491:96537", + "bound_var": "b1117", + "source_text": "ctx.insert_t51_add(b87.clone(), b1116.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1116", + "b87" + ], + "range": { + "start": 96491, + "end": 96537 + } + }, + { + "id": "effect_1337", + "effect_id": "effect@96563:96614", + "bound_var": "b1118", + "source_text": "ctx.insert_t51_mul(slambda2.clone(), b1117.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1117", + "slambda2" + ], + "range": { + "start": 96563, + "end": 96614 + } + }, + { + "id": "effect_1338", + "effect_id": "effect@96640:96686", + "bound_var": "b1119", + "source_text": "ctx.insert_t51_mul(b49.clone(), b1118.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1118", + "b49" + ], + "range": { + "start": 96640, + "end": 96686 + } + }, + { + "id": "effect_1339", + "effect_id": "effect@96712:96770", + "bound_var": "b1120", + "source_text": "ctx.insert_t51_lower(b1119.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1119" + ], + "range": { + "start": 96712, + "end": 96770 + } + }, + { + "id": "effect_1340", + "effect_id": "effect@96796:96846", + "bound_var": "r1121", + "source_text": "ctx.insert_t51_approx(b349.clone(), b1120.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1120", + "b349" + ], + "range": { + "start": 96796, + "end": 96846 + } + }, + { + "id": "effect_1341", + "effect_id": "effect@96860:96899", + "bound_var": null, + "source_text": "ctx.set_to_extract(1127, r1121.clone())", + "semantic_text": "to_extract(1127) = r1121", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1121" + ], + "range": { + "start": 96860, + "end": 96899 + } + }, + { + "id": "effect_1342", + "effect_id": "effect@96925:96957", + "bound_var": "b1122", + "source_text": "ctx.insert_t51_sin(b938.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b938" + ], + "range": { + "start": 96925, + "end": 96957 + } + }, + { + "id": "effect_1343", + "effect_id": "effect@96983:97041", + "bound_var": "b1123", + "source_text": "ctx.insert_t51_lower(b1122.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1122" + ], + "range": { + "start": 96983, + "end": 97041 + } + }, + { + "id": "effect_1344", + "effect_id": "effect@97067:97117", + "bound_var": "r1124", + "source_text": "ctx.insert_t51_approx(b358.clone(), b1123.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1123", + "b358" + ], + "range": { + "start": 97067, + "end": 97117 + } + }, + { + "id": "effect_1345", + "effect_id": "effect@97131:97170", + "bound_var": null, + "source_text": "ctx.set_to_extract(1130, r1124.clone())", + "semantic_text": "to_extract(1130) = r1124", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1124" + ], + "range": { + "start": 97131, + "end": 97170 + } + }, + { + "id": "effect_1346", + "effect_id": "effect@97196:97244", + "bound_var": "b1125", + "source_text": "ctx.insert_t51_add(b1122.clone(), b1112.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1112", + "b1122" + ], + "range": { + "start": 97196, + "end": 97244 + } + }, + { + "id": "effect_1347", + "effect_id": "effect@97270:97328", + "bound_var": "b1126", + "source_text": "ctx.insert_t51_lower(b1125.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1125" + ], + "range": { + "start": 97270, + "end": 97328 + } + }, + { + "id": "effect_1348", + "effect_id": "effect@97354:97404", + "bound_var": "r1127", + "source_text": "ctx.insert_t51_approx(b383.clone(), b1126.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1126", + "b383" + ], + "range": { + "start": 97354, + "end": 97404 + } + }, + { + "id": "effect_1349", + "effect_id": "effect@97418:97457", + "bound_var": null, + "source_text": "ctx.set_to_extract(1133, r1127.clone())", + "semantic_text": "to_extract(1133) = r1127", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1127" + ], + "range": { + "start": 97418, + "end": 97457 + } + }, + { + "id": "effect_1350", + "effect_id": "effect@97483:97529", + "bound_var": "b1128", + "source_text": "ctx.insert_t51_mul(b98.clone(), b1125.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1125", + "b98" + ], + "range": { + "start": 97483, + "end": 97529 + } + }, + { + "id": "effect_1351", + "effect_id": "effect@97555:97613", + "bound_var": "b1129", + "source_text": "ctx.insert_t51_lower(b1128.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1128" + ], + "range": { + "start": 97555, + "end": 97613 + } + }, + { + "id": "effect_1352", + "effect_id": "effect@97639:97689", + "bound_var": "r1130", + "source_text": "ctx.insert_t51_approx(b416.clone(), b1129.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1129", + "b416" + ], + "range": { + "start": 97639, + "end": 97689 + } + }, + { + "id": "effect_1353", + "effect_id": "effect@97703:97742", + "bound_var": null, + "source_text": "ctx.set_to_extract(1136, r1130.clone())", + "semantic_text": "to_extract(1136) = r1130", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1130" + ], + "range": { + "start": 97703, + "end": 97742 + } + }, + { + "id": "effect_1354", + "effect_id": "effect@97768:97815", + "bound_var": "b1131", + "source_text": "ctx.insert_t51_add(b1128.clone(), b279.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1128", + "b279" + ], + "range": { + "start": 97768, + "end": 97815 + } + }, + { + "id": "effect_1355", + "effect_id": "effect@97841:97899", + "bound_var": "b1132", + "source_text": "ctx.insert_t51_lower(b1131.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1131" + ], + "range": { + "start": 97841, + "end": 97899 + } + }, + { + "id": "effect_1356", + "effect_id": "effect@97925:97975", + "bound_var": "r1133", + "source_text": "ctx.insert_t51_approx(b440.clone(), b1132.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1132", + "b440" + ], + "range": { + "start": 97925, + "end": 97975 + } + }, + { + "id": "effect_1357", + "effect_id": "effect@97989:98028", + "bound_var": null, + "source_text": "ctx.set_to_extract(1139, r1133.clone())", + "semantic_text": "to_extract(1139) = r1133", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1133" + ], + "range": { + "start": 97989, + "end": 98028 + } + }, + { + "id": "effect_1358", + "effect_id": "effect@98054:98100", + "bound_var": "b1134", + "source_text": "ctx.insert_t51_add(b1089.clone(), b10.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b10", + "b1089" + ], + "range": { + "start": 98054, + "end": 98100 + } + }, + { + "id": "effect_1359", + "effect_id": "effect@98126:98184", + "bound_var": "b1135", + "source_text": "ctx.insert_t51_lower(b1134.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1134" + ], + "range": { + "start": 98126, + "end": 98184 + } + }, + { + "id": "effect_1360", + "effect_id": "effect@98210:98259", + "bound_var": "r1136", + "source_text": "ctx.insert_t51_approx(b19.clone(), b1135.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1135", + "b19" + ], + "range": { + "start": 98210, + "end": 98259 + } + }, + { + "id": "effect_1361", + "effect_id": "effect@98273:98312", + "bound_var": null, + "source_text": "ctx.set_to_extract(1142, r1136.clone())", + "semantic_text": "to_extract(1142) = r1136", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1136" + ], + "range": { + "start": 98273, + "end": 98312 + } + }, + { + "id": "effect_1362", + "effect_id": "effect@98338:98372", + "bound_var": "b1137", + "source_text": "ctx.insert_t51_acos(b1134.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1134" + ], + "range": { + "start": 98338, + "end": 98372 + } + }, + { + "id": "effect_1363", + "effect_id": "effect@98398:98456", + "bound_var": "b1138", + "source_text": "ctx.insert_t51_lower(b1137.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1137" + ], + "range": { + "start": 98398, + "end": 98456 + } + }, + { + "id": "effect_1364", + "effect_id": "effect@98482:98531", + "bound_var": "r1139", + "source_text": "ctx.insert_t51_approx(b20.clone(), b1138.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1138", + "b20" + ], + "range": { + "start": 98482, + "end": 98531 + } + }, + { + "id": "effect_1365", + "effect_id": "effect@98545:98584", + "bound_var": null, + "source_text": "ctx.set_to_extract(1145, r1139.clone())", + "semantic_text": "to_extract(1145) = r1139", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1139" + ], + "range": { + "start": 98545, + "end": 98584 + } + }, + { + "id": "effect_1366", + "effect_id": "effect@98610:98655", + "bound_var": "b1140", + "source_text": "ctx.insert_t51_mul(sR.clone(), b1137.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1137", + "sR" + ], + "range": { + "start": 98610, + "end": 98655 + } + }, + { + "id": "effect_1367", + "effect_id": "effect@98681:98739", + "bound_var": "b1141", + "source_text": "ctx.insert_t51_lower(b1140.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1140" + ], + "range": { + "start": 98681, + "end": 98739 + } + }, + { + "id": "effect_1368", + "effect_id": "effect@98765:98814", + "bound_var": "r1142", + "source_text": "ctx.insert_t51_approx(b21.clone(), b1141.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1141", + "b21" + ], + "range": { + "start": 98765, + "end": 98814 + } + }, + { + "id": "effect_1369", + "effect_id": "effect@98828:98867", + "bound_var": null, + "source_text": "ctx.set_to_extract(1148, r1142.clone())", + "semantic_text": "to_extract(1148) = r1142", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1142" + ], + "range": { + "start": 98828, + "end": 98867 + } + }, + { + "id": "effect_1370", + "effect_id": "effect@98893:98951", + "bound_var": "b1143", + "source_text": "ctx.insert_t51_lower(sphi1.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "sphi1" + ], + "range": { + "start": 98893, + "end": 98951 + } + }, + { + "id": "effect_1371", + "effect_id": "effect@98977:99028", + "bound_var": "r1144", + "source_text": "ctx.insert_t51_approx(sphi1.clone(), b1143.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1143", + "sphi1" + ], + "range": { + "start": 98977, + "end": 99028 + } + }, + { + "id": "effect_1372", + "effect_id": "effect@99042:99081", + "bound_var": null, + "source_text": "ctx.set_to_extract(1150, r1144.clone())", + "semantic_text": "to_extract(1150) = r1144", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1144" + ], + "range": { + "start": 99042, + "end": 99081 + } + }, + { + "id": "effect_1373", + "effect_id": "effect@99107:99153", + "bound_var": "b1145", + "source_text": "ctx.insert_t51_pow(sphi1.clone(), b90.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b90", + "sphi1" + ], + "range": { + "start": 99107, + "end": 99153 + } + }, + { + "id": "effect_1374", + "effect_id": "effect@99179:99226", + "bound_var": "b1146", + "source_text": "ctx.insert_t51_mul(b113.clone(), b1145.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b1145" + ], + "range": { + "start": 99179, + "end": 99226 + } + }, + { + "id": "effect_1375", + "effect_id": "effect@99252:99298", + "bound_var": "b1147", + "source_text": "ctx.insert_t51_add(b87.clone(), b1146.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1146", + "b87" + ], + "range": { + "start": 99252, + "end": 99298 + } + }, + { + "id": "effect_1376", + "effect_id": "effect@99324:99372", + "bound_var": "b1148", + "source_text": "ctx.insert_t51_mul(sphi1.clone(), b1147.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1147", + "sphi1" + ], + "range": { + "start": 99324, + "end": 99372 + } + }, + { + "id": "effect_1377", + "effect_id": "effect@99398:99456", + "bound_var": "b1149", + "source_text": "ctx.insert_t51_lower(b1148.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1148" + ], + "range": { + "start": 99398, + "end": 99456 + } + }, + { + "id": "effect_1378", + "effect_id": "effect@99482:99530", + "bound_var": "r1150", + "source_text": "ctx.insert_t51_approx(b7.clone(), b1149.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1149", + "b7" + ], + "range": { + "start": 99482, + "end": 99530 + } + }, + { + "id": "effect_1379", + "effect_id": "effect@99544:99583", + "bound_var": null, + "source_text": "ctx.set_to_extract(1156, r1150.clone())", + "semantic_text": "to_extract(1156) = r1150", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1150" + ], + "range": { + "start": 99544, + "end": 99583 + } + }, + { + "id": "effect_1380", + "effect_id": "effect@99609:99656", + "bound_var": "b1151", + "source_text": "ctx.insert_t51_mul(b119.clone(), b1145.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1145", + "b119" + ], + "range": { + "start": 99609, + "end": 99656 + } + }, + { + "id": "effect_1381", + "effect_id": "effect@99682:99728", + "bound_var": "b1152", + "source_text": "ctx.insert_t51_sub(b1151.clone(), b74.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1151", + "b74" + ], + "range": { + "start": 99682, + "end": 99728 + } + }, + { + "id": "effect_1382", + "effect_id": "effect@99754:99802", + "bound_var": "b1153", + "source_text": "ctx.insert_t51_mul(b1145.clone(), b1152.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1145", + "b1152" + ], + "range": { + "start": 99754, + "end": 99802 + } + }, + { + "id": "effect_1383", + "effect_id": "effect@99828:99874", + "bound_var": "b1154", + "source_text": "ctx.insert_t51_add(b87.clone(), b1153.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1153", + "b87" + ], + "range": { + "start": 99828, + "end": 99874 + } + }, + { + "id": "effect_1384", + "effect_id": "effect@99900:99948", + "bound_var": "b1155", + "source_text": "ctx.insert_t51_mul(sphi1.clone(), b1154.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1154", + "sphi1" + ], + "range": { + "start": 99900, + "end": 99948 + } + }, + { + "id": "effect_1385", + "effect_id": "effect@99974:100032", + "bound_var": "b1156", + "source_text": "ctx.insert_t51_lower(b1155.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1155" + ], + "range": { + "start": 99974, + "end": 100032 + } + }, + { + "id": "effect_1386", + "effect_id": "effect@100058:100106", + "bound_var": "r1157", + "source_text": "ctx.insert_t51_approx(b7.clone(), b1156.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1156", + "b7" + ], + "range": { + "start": 100058, + "end": 100106 + } + }, + { + "id": "effect_1387", + "effect_id": "effect@100120:100159", + "bound_var": null, + "source_text": "ctx.set_to_extract(1163, r1157.clone())", + "semantic_text": "to_extract(1163) = r1157", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1157" + ], + "range": { + "start": 100120, + "end": 100159 + } + }, + { + "id": "effect_1388", + "effect_id": "effect@100185:100232", + "bound_var": "b1158", + "source_text": "ctx.insert_t51_mul(b127.clone(), b1145.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1145", + "b127" + ], + "range": { + "start": 100185, + "end": 100232 + } + }, + { + "id": "effect_1389", + "effect_id": "effect@100258:100305", + "bound_var": "b1159", + "source_text": "ctx.insert_t51_add(b119.clone(), b1158.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1158", + "b119" + ], + "range": { + "start": 100258, + "end": 100305 + } + }, + { + "id": "effect_1390", + "effect_id": "effect@100331:100379", + "bound_var": "b1160", + "source_text": "ctx.insert_t51_mul(b1145.clone(), b1159.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1145", + "b1159" + ], + "range": { + "start": 100331, + "end": 100379 + } + }, + { + "id": "effect_1391", + "effect_id": "effect@100405:100451", + "bound_var": "b1161", + "source_text": "ctx.insert_t51_sub(b1160.clone(), b74.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1160", + "b74" + ], + "range": { + "start": 100405, + "end": 100451 + } + }, + { + "id": "effect_1392", + "effect_id": "effect@100477:100525", + "bound_var": "b1162", + "source_text": "ctx.insert_t51_mul(b1145.clone(), b1161.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1145", + "b1161" + ], + "range": { + "start": 100477, + "end": 100525 + } + }, + { + "id": "effect_1393", + "effect_id": "effect@100551:100597", + "bound_var": "b1163", + "source_text": "ctx.insert_t51_add(b87.clone(), b1162.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1162", + "b87" + ], + "range": { + "start": 100551, + "end": 100597 + } + }, + { + "id": "effect_1394", + "effect_id": "effect@100623:100671", + "bound_var": "b1164", + "source_text": "ctx.insert_t51_mul(sphi1.clone(), b1163.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1163", + "sphi1" + ], + "range": { + "start": 100623, + "end": 100671 + } + }, + { + "id": "effect_1395", + "effect_id": "effect@100697:100755", + "bound_var": "b1165", + "source_text": "ctx.insert_t51_lower(b1164.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1164" + ], + "range": { + "start": 100697, + "end": 100755 + } + }, + { + "id": "effect_1396", + "effect_id": "effect@100781:100829", + "bound_var": "r1166", + "source_text": "ctx.insert_t51_approx(b7.clone(), b1165.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1165", + "b7" + ], + "range": { + "start": 100781, + "end": 100829 + } + }, + { + "id": "effect_1397", + "effect_id": "effect@100843:100882", + "bound_var": null, + "source_text": "ctx.set_to_extract(1172, r1166.clone())", + "semantic_text": "to_extract(1172) = r1166", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1166" + ], + "range": { + "start": 100843, + "end": 100882 + } + }, + { + "id": "effect_1398", + "effect_id": "effect@100908:100965", + "bound_var": "b1167", + "source_text": "ctx.insert_t51_lower(b279.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b279" + ], + "range": { + "start": 100908, + "end": 100965 + } + }, + { + "id": "effect_1399", + "effect_id": "effect@100991:101040", + "bound_var": "r1168", + "source_text": "ctx.insert_t51_approx(b10.clone(), b1167.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b10", + "b1167" + ], + "range": { + "start": 100991, + "end": 101040 + } + }, + { + "id": "effect_1400", + "effect_id": "effect@101054:101093", + "bound_var": null, + "source_text": "ctx.set_to_extract(1174, r1168.clone())", + "semantic_text": "to_extract(1174) = r1168", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1168" + ], + "range": { + "start": 101054, + "end": 101093 + } + }, + { + "id": "effect_1401", + "effect_id": "effect@101119:101164", + "bound_var": "b1169", + "source_text": "ctx.insert_t51_mul(b1145.clone(), b9.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1145", + "b9" + ], + "range": { + "start": 101119, + "end": 101164 + } + }, + { + "id": "effect_1402", + "effect_id": "effect@101190:101237", + "bound_var": "b1170", + "source_text": "ctx.insert_t51_mul(b113.clone(), b1169.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b1169" + ], + "range": { + "start": 101190, + "end": 101237 + } + }, + { + "id": "effect_1403", + "effect_id": "effect@101263:101308", + "bound_var": "b1171", + "source_text": "ctx.insert_t51_add(b9.clone(), b1170.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1170", + "b9" + ], + "range": { + "start": 101263, + "end": 101308 + } + }, + { + "id": "effect_1404", + "effect_id": "effect@101334:101382", + "bound_var": "b1172", + "source_text": "ctx.insert_t51_mul(sphi1.clone(), b1171.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1171", + "sphi1" + ], + "range": { + "start": 101334, + "end": 101382 + } + }, + { + "id": "effect_1405", + "effect_id": "effect@101408:101466", + "bound_var": "b1173", + "source_text": "ctx.insert_t51_lower(b1172.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1172" + ], + "range": { + "start": 101408, + "end": 101466 + } + }, + { + "id": "effect_1406", + "effect_id": "effect@101492:101541", + "bound_var": "r1174", + "source_text": "ctx.insert_t51_approx(b10.clone(), b1173.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b10", + "b1173" + ], + "range": { + "start": 101492, + "end": 101541 + } + }, + { + "id": "effect_1407", + "effect_id": "effect@101555:101594", + "bound_var": null, + "source_text": "ctx.set_to_extract(1180, r1174.clone())", + "semantic_text": "to_extract(1180) = r1174", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1174" + ], + "range": { + "start": 101555, + "end": 101594 + } + }, + { + "id": "effect_1408", + "effect_id": "effect@101620:101664", + "bound_var": "b1175", + "source_text": "ctx.insert_t51_mul(b113.clone(), b9.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b9" + ], + "range": { + "start": 101620, + "end": 101664 + } + }, + { + "id": "effect_1409", + "effect_id": "effect@101690:101737", + "bound_var": "b1176", + "source_text": "ctx.insert_t51_mul(b119.clone(), b1169.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1169", + "b119" + ], + "range": { + "start": 101690, + "end": 101737 + } + }, + { + "id": "effect_1410", + "effect_id": "effect@101763:101811", + "bound_var": "b1177", + "source_text": "ctx.insert_t51_add(b1175.clone(), b1176.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1175", + "b1176" + ], + "range": { + "start": 101763, + "end": 101811 + } + }, + { + "id": "effect_1411", + "effect_id": "effect@101837:101885", + "bound_var": "b1178", + "source_text": "ctx.insert_t51_mul(b1145.clone(), b1177.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1145", + "b1177" + ], + "range": { + "start": 101837, + "end": 101885 + } + }, + { + "id": "effect_1412", + "effect_id": "effect@101911:101956", + "bound_var": "b1179", + "source_text": "ctx.insert_t51_add(b9.clone(), b1178.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1178", + "b9" + ], + "range": { + "start": 101911, + "end": 101956 + } + }, + { + "id": "effect_1413", + "effect_id": "effect@101982:102030", + "bound_var": "b1180", + "source_text": "ctx.insert_t51_mul(sphi1.clone(), b1179.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1179", + "sphi1" + ], + "range": { + "start": 101982, + "end": 102030 + } + }, + { + "id": "effect_1414", + "effect_id": "effect@102056:102114", + "bound_var": "b1181", + "source_text": "ctx.insert_t51_lower(b1180.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1180" + ], + "range": { + "start": 102056, + "end": 102114 + } + }, + { + "id": "effect_1415", + "effect_id": "effect@102140:102189", + "bound_var": "r1182", + "source_text": "ctx.insert_t51_approx(b10.clone(), b1181.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b10", + "b1181" + ], + "range": { + "start": 102140, + "end": 102189 + } + }, + { + "id": "effect_1416", + "effect_id": "effect@102203:102242", + "bound_var": null, + "source_text": "ctx.set_to_extract(1188, r1182.clone())", + "semantic_text": "to_extract(1188) = r1182", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1182" + ], + "range": { + "start": 102203, + "end": 102242 + } + }, + { + "id": "effect_1417", + "effect_id": "effect@102268:102315", + "bound_var": "b1183", + "source_text": "ctx.insert_t51_mul(b127.clone(), b1169.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1169", + "b127" + ], + "range": { + "start": 102268, + "end": 102315 + } + }, + { + "id": "effect_1418", + "effect_id": "effect@102341:102385", + "bound_var": "b1184", + "source_text": "ctx.insert_t51_mul(b119.clone(), b9.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b119", + "b9" + ], + "range": { + "start": 102341, + "end": 102385 + } + }, + { + "id": "effect_1419", + "effect_id": "effect@102411:102459", + "bound_var": "b1185", + "source_text": "ctx.insert_t51_add(b1183.clone(), b1184.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1183", + "b1184" + ], + "range": { + "start": 102411, + "end": 102459 + } + }, + { + "id": "effect_1420", + "effect_id": "effect@102485:102533", + "bound_var": "b1186", + "source_text": "ctx.insert_t51_mul(b1145.clone(), b1185.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1145", + "b1185" + ], + "range": { + "start": 102485, + "end": 102533 + } + }, + { + "id": "effect_1421", + "effect_id": "effect@102559:102607", + "bound_var": "b1187", + "source_text": "ctx.insert_t51_add(b1175.clone(), b1186.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1175", + "b1186" + ], + "range": { + "start": 102559, + "end": 102607 + } + }, + { + "id": "effect_1422", + "effect_id": "effect@102633:102681", + "bound_var": "b1188", + "source_text": "ctx.insert_t51_mul(b1145.clone(), b1187.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1145", + "b1187" + ], + "range": { + "start": 102633, + "end": 102681 + } + }, + { + "id": "effect_1423", + "effect_id": "effect@102707:102752", + "bound_var": "b1189", + "source_text": "ctx.insert_t51_add(b9.clone(), b1188.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1188", + "b9" + ], + "range": { + "start": 102707, + "end": 102752 + } + }, + { + "id": "effect_1424", + "effect_id": "effect@102778:102826", + "bound_var": "b1190", + "source_text": "ctx.insert_t51_mul(sphi1.clone(), b1189.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1189", + "sphi1" + ], + "range": { + "start": 102778, + "end": 102826 + } + }, + { + "id": "effect_1425", + "effect_id": "effect@102852:102910", + "bound_var": "b1191", + "source_text": "ctx.insert_t51_lower(b1190.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1190" + ], + "range": { + "start": 102852, + "end": 102910 + } + }, + { + "id": "effect_1426", + "effect_id": "effect@102936:102985", + "bound_var": "r1192", + "source_text": "ctx.insert_t51_approx(b10.clone(), b1191.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b10", + "b1191" + ], + "range": { + "start": 102936, + "end": 102985 + } + }, + { + "id": "effect_1427", + "effect_id": "effect@102999:103038", + "bound_var": null, + "source_text": "ctx.set_to_extract(1198, r1192.clone())", + "semantic_text": "to_extract(1198) = r1192", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1192" + ], + "range": { + "start": 102999, + "end": 103038 + } + }, + { + "id": "effect_1428", + "effect_id": "effect@103064:103110", + "bound_var": "b1193", + "source_text": "ctx.insert_t51_mul(b65.clone(), b1145.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1145", + "b65" + ], + "range": { + "start": 103064, + "end": 103110 + } + }, + { + "id": "effect_1429", + "effect_id": "effect@103136:103182", + "bound_var": "b1194", + "source_text": "ctx.insert_t51_add(b87.clone(), b1193.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1193", + "b87" + ], + "range": { + "start": 103136, + "end": 103182 + } + }, + { + "id": "effect_1430", + "effect_id": "effect@103208:103266", + "bound_var": "b1195", + "source_text": "ctx.insert_t51_lower(b1194.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1194" + ], + "range": { + "start": 103208, + "end": 103266 + } + }, + { + "id": "effect_1431", + "effect_id": "effect@103292:103341", + "bound_var": "r1196", + "source_text": "ctx.insert_t51_approx(b11.clone(), b1195.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b11", + "b1195" + ], + "range": { + "start": 103292, + "end": 103341 + } + }, + { + "id": "effect_1432", + "effect_id": "effect@103355:103394", + "bound_var": null, + "source_text": "ctx.set_to_extract(1202, r1196.clone())", + "semantic_text": "to_extract(1202) = r1196", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1196" + ], + "range": { + "start": 103355, + "end": 103394 + } + }, + { + "id": "effect_1433", + "effect_id": "effect@103420:103466", + "bound_var": "b1197", + "source_text": "ctx.insert_t51_mul(b96.clone(), b1145.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1145", + "b96" + ], + "range": { + "start": 103420, + "end": 103466 + } + }, + { + "id": "effect_1434", + "effect_id": "effect@103492:103538", + "bound_var": "b1198", + "source_text": "ctx.insert_t51_sub(b1197.clone(), b98.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1197", + "b98" + ], + "range": { + "start": 103492, + "end": 103538 + } + }, + { + "id": "effect_1435", + "effect_id": "effect@103564:103612", + "bound_var": "b1199", + "source_text": "ctx.insert_t51_mul(b1145.clone(), b1198.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1145", + "b1198" + ], + "range": { + "start": 103564, + "end": 103612 + } + }, + { + "id": "effect_1436", + "effect_id": "effect@103638:103684", + "bound_var": "b1200", + "source_text": "ctx.insert_t51_add(b87.clone(), b1199.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1199", + "b87" + ], + "range": { + "start": 103638, + "end": 103684 + } + }, + { + "id": "effect_1437", + "effect_id": "effect@103710:103768", + "bound_var": "b1201", + "source_text": "ctx.insert_t51_lower(b1200.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1200" + ], + "range": { + "start": 103710, + "end": 103768 + } + }, + { + "id": "effect_1438", + "effect_id": "effect@103794:103843", + "bound_var": "r1202", + "source_text": "ctx.insert_t51_approx(b11.clone(), b1201.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b11", + "b1201" + ], + "range": { + "start": 103794, + "end": 103843 + } + }, + { + "id": "effect_1439", + "effect_id": "effect@103857:103896", + "bound_var": null, + "source_text": "ctx.set_to_extract(1208, r1202.clone())", + "semantic_text": "to_extract(1208) = r1202", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1202" + ], + "range": { + "start": 103857, + "end": 103896 + } + }, + { + "id": "effect_1440", + "effect_id": "effect@103922:103969", + "bound_var": "b1203", + "source_text": "ctx.insert_t51_mul(b104.clone(), b1145.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b104", + "b1145" + ], + "range": { + "start": 103922, + "end": 103969 + } + }, + { + "id": "effect_1441", + "effect_id": "effect@103995:104041", + "bound_var": "b1204", + "source_text": "ctx.insert_t51_add(b96.clone(), b1203.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1203", + "b96" + ], + "range": { + "start": 103995, + "end": 104041 + } + }, + { + "id": "effect_1442", + "effect_id": "effect@104067:104115", + "bound_var": "b1205", + "source_text": "ctx.insert_t51_mul(b1145.clone(), b1204.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1145", + "b1204" + ], + "range": { + "start": 104067, + "end": 104115 + } + }, + { + "id": "effect_1443", + "effect_id": "effect@104141:104187", + "bound_var": "b1206", + "source_text": "ctx.insert_t51_sub(b1205.clone(), b98.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1205", + "b98" + ], + "range": { + "start": 104141, + "end": 104187 + } + }, + { + "id": "effect_1444", + "effect_id": "effect@104213:104261", + "bound_var": "b1207", + "source_text": "ctx.insert_t51_mul(b1145.clone(), b1206.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1145", + "b1206" + ], + "range": { + "start": 104213, + "end": 104261 + } + }, + { + "id": "effect_1445", + "effect_id": "effect@104287:104333", + "bound_var": "b1208", + "source_text": "ctx.insert_t51_add(b87.clone(), b1207.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1207", + "b87" + ], + "range": { + "start": 104287, + "end": 104333 + } + }, + { + "id": "effect_1446", + "effect_id": "effect@104359:104417", + "bound_var": "b1209", + "source_text": "ctx.insert_t51_lower(b1208.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1208" + ], + "range": { + "start": 104359, + "end": 104417 + } + }, + { + "id": "effect_1447", + "effect_id": "effect@104443:104492", + "bound_var": "r1210", + "source_text": "ctx.insert_t51_approx(b11.clone(), b1209.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b11", + "b1209" + ], + "range": { + "start": 104443, + "end": 104492 + } + }, + { + "id": "effect_1448", + "effect_id": "effect@104506:104545", + "bound_var": null, + "source_text": "ctx.set_to_extract(1216, r1210.clone())", + "semantic_text": "to_extract(1216) = r1210", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1210" + ], + "range": { + "start": 104506, + "end": 104545 + } + }, + { + "id": "effect_1449", + "effect_id": "effect@104571:104627", + "bound_var": "b1211", + "source_text": "ctx.insert_t51_lower(b12.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b12" + ], + "range": { + "start": 104571, + "end": 104627 + } + }, + { + "id": "effect_1450", + "effect_id": "effect@104653:104702", + "bound_var": "r1212", + "source_text": "ctx.insert_t51_approx(b13.clone(), b1211.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1211", + "b13" + ], + "range": { + "start": 104653, + "end": 104702 + } + }, + { + "id": "effect_1451", + "effect_id": "effect@104716:104755", + "bound_var": null, + "source_text": "ctx.set_to_extract(1218, r1212.clone())", + "semantic_text": "to_extract(1218) = r1212", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1212" + ], + "range": { + "start": 104716, + "end": 104755 + } + }, + { + "id": "effect_1452", + "effect_id": "effect@104781:104827", + "bound_var": "b1213", + "source_text": "ctx.insert_t51_mul(b1145.clone(), b12.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1145", + "b12" + ], + "range": { + "start": 104781, + "end": 104827 + } + }, + { + "id": "effect_1453", + "effect_id": "effect@104853:104899", + "bound_var": "b1214", + "source_text": "ctx.insert_t51_mul(b65.clone(), b1213.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1213", + "b65" + ], + "range": { + "start": 104853, + "end": 104899 + } + }, + { + "id": "effect_1454", + "effect_id": "effect@104925:104971", + "bound_var": "b1215", + "source_text": "ctx.insert_t51_add(b12.clone(), b1214.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b12", + "b1214" + ], + "range": { + "start": 104925, + "end": 104971 + } + }, + { + "id": "effect_1455", + "effect_id": "effect@104997:105055", + "bound_var": "b1216", + "source_text": "ctx.insert_t51_lower(b1215.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1215" + ], + "range": { + "start": 104997, + "end": 105055 + } + }, + { + "id": "effect_1456", + "effect_id": "effect@105081:105130", + "bound_var": "r1217", + "source_text": "ctx.insert_t51_approx(b13.clone(), b1216.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1216", + "b13" + ], + "range": { + "start": 105081, + "end": 105130 + } + }, + { + "id": "effect_1457", + "effect_id": "effect@105144:105183", + "bound_var": null, + "source_text": "ctx.set_to_extract(1223, r1217.clone())", + "semantic_text": "to_extract(1223) = r1217", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1217" + ], + "range": { + "start": 105144, + "end": 105183 + } + }, + { + "id": "effect_1458", + "effect_id": "effect@105209:105253", + "bound_var": "b1218", + "source_text": "ctx.insert_t51_mul(b65.clone(), b12.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b12", + "b65" + ], + "range": { + "start": 105209, + "end": 105253 + } + }, + { + "id": "effect_1459", + "effect_id": "effect@105279:105325", + "bound_var": "b1219", + "source_text": "ctx.insert_t51_mul(b96.clone(), b1213.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1213", + "b96" + ], + "range": { + "start": 105279, + "end": 105325 + } + }, + { + "id": "effect_1460", + "effect_id": "effect@105351:105399", + "bound_var": "b1220", + "source_text": "ctx.insert_t51_add(b1218.clone(), b1219.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1218", + "b1219" + ], + "range": { + "start": 105351, + "end": 105399 + } + }, + { + "id": "effect_1461", + "effect_id": "effect@105425:105473", + "bound_var": "b1221", + "source_text": "ctx.insert_t51_mul(b1145.clone(), b1220.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1145", + "b1220" + ], + "range": { + "start": 105425, + "end": 105473 + } + }, + { + "id": "effect_1462", + "effect_id": "effect@105499:105545", + "bound_var": "b1222", + "source_text": "ctx.insert_t51_add(b12.clone(), b1221.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b12", + "b1221" + ], + "range": { + "start": 105499, + "end": 105545 + } + }, + { + "id": "effect_1463", + "effect_id": "effect@105571:105629", + "bound_var": "b1223", + "source_text": "ctx.insert_t51_lower(b1222.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1222" + ], + "range": { + "start": 105571, + "end": 105629 + } + }, + { + "id": "effect_1464", + "effect_id": "effect@105655:105704", + "bound_var": "r1224", + "source_text": "ctx.insert_t51_approx(b13.clone(), b1223.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1223", + "b13" + ], + "range": { + "start": 105655, + "end": 105704 + } + }, + { + "id": "effect_1465", + "effect_id": "effect@105718:105757", + "bound_var": null, + "source_text": "ctx.set_to_extract(1230, r1224.clone())", + "semantic_text": "to_extract(1230) = r1224", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1224" + ], + "range": { + "start": 105718, + "end": 105757 + } + }, + { + "id": "effect_1466", + "effect_id": "effect@105783:105830", + "bound_var": "b1225", + "source_text": "ctx.insert_t51_mul(b104.clone(), b1213.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b104", + "b1213" + ], + "range": { + "start": 105783, + "end": 105830 + } + }, + { + "id": "effect_1467", + "effect_id": "effect@105856:105900", + "bound_var": "b1226", + "source_text": "ctx.insert_t51_mul(b96.clone(), b12.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b12", + "b96" + ], + "range": { + "start": 105856, + "end": 105900 + } + }, + { + "id": "effect_1468", + "effect_id": "effect@105926:105974", + "bound_var": "b1227", + "source_text": "ctx.insert_t51_add(b1225.clone(), b1226.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1225", + "b1226" + ], + "range": { + "start": 105926, + "end": 105974 + } + }, + { + "id": "effect_1469", + "effect_id": "effect@106000:106048", + "bound_var": "b1228", + "source_text": "ctx.insert_t51_mul(b1145.clone(), b1227.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1145", + "b1227" + ], + "range": { + "start": 106000, + "end": 106048 + } + }, + { + "id": "effect_1470", + "effect_id": "effect@106074:106122", + "bound_var": "b1229", + "source_text": "ctx.insert_t51_add(b1218.clone(), b1228.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1218", + "b1228" + ], + "range": { + "start": 106074, + "end": 106122 + } + }, + { + "id": "effect_1471", + "effect_id": "effect@106148:106196", + "bound_var": "b1230", + "source_text": "ctx.insert_t51_mul(b1145.clone(), b1229.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1145", + "b1229" + ], + "range": { + "start": 106148, + "end": 106196 + } + }, + { + "id": "effect_1472", + "effect_id": "effect@106222:106268", + "bound_var": "b1231", + "source_text": "ctx.insert_t51_add(b12.clone(), b1230.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b12", + "b1230" + ], + "range": { + "start": 106222, + "end": 106268 + } + }, + { + "id": "effect_1473", + "effect_id": "effect@106294:106352", + "bound_var": "b1232", + "source_text": "ctx.insert_t51_lower(b1231.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1231" + ], + "range": { + "start": 106294, + "end": 106352 + } + }, + { + "id": "effect_1474", + "effect_id": "effect@106378:106427", + "bound_var": "r1233", + "source_text": "ctx.insert_t51_approx(b13.clone(), b1232.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1232", + "b13" + ], + "range": { + "start": 106378, + "end": 106427 + } + }, + { + "id": "effect_1475", + "effect_id": "effect@106441:106480", + "bound_var": null, + "source_text": "ctx.set_to_extract(1239, r1233.clone())", + "semantic_text": "to_extract(1239) = r1233", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1233" + ], + "range": { + "start": 106441, + "end": 106480 + } + }, + { + "id": "effect_1476", + "effect_id": "effect@106506:106551", + "bound_var": "b1234", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b7.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b7", + "sphi2" + ], + "range": { + "start": 106506, + "end": 106551 + } + }, + { + "id": "effect_1477", + "effect_id": "effect@106577:106634", + "bound_var": "b1235", + "source_text": "ctx.insert_t51_lower(b262.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b262" + ], + "range": { + "start": 106577, + "end": 106634 + } + }, + { + "id": "effect_1478", + "effect_id": "effect@106660:106711", + "bound_var": "r1236", + "source_text": "ctx.insert_t51_approx(b1234.clone(), b1235.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1234", + "b1235" + ], + "range": { + "start": 106660, + "end": 106711 + } + }, + { + "id": "effect_1479", + "effect_id": "effect@106725:106764", + "bound_var": null, + "source_text": "ctx.set_to_extract(1242, r1236.clone())", + "semantic_text": "to_extract(1242) = r1236", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1236" + ], + "range": { + "start": 106725, + "end": 106764 + } + }, + { + "id": "effect_1480", + "effect_id": "effect@106790:106838", + "bound_var": "b1237", + "source_text": "ctx.insert_t51_mul(b1145.clone(), sphi2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1145", + "sphi2" + ], + "range": { + "start": 106790, + "end": 106838 + } + }, + { + "id": "effect_1481", + "effect_id": "effect@106864:106911", + "bound_var": "b1238", + "source_text": "ctx.insert_t51_mul(b113.clone(), b1237.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b1237" + ], + "range": { + "start": 106864, + "end": 106911 + } + }, + { + "id": "effect_1482", + "effect_id": "effect@106937:106985", + "bound_var": "b1239", + "source_text": "ctx.insert_t51_add(sphi2.clone(), b1238.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1238", + "sphi2" + ], + "range": { + "start": 106937, + "end": 106985 + } + }, + { + "id": "effect_1483", + "effect_id": "effect@107011:107059", + "bound_var": "b1240", + "source_text": "ctx.insert_t51_mul(sphi1.clone(), b1239.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1239", + "sphi1" + ], + "range": { + "start": 107011, + "end": 107059 + } + }, + { + "id": "effect_1484", + "effect_id": "effect@107085:107143", + "bound_var": "b1241", + "source_text": "ctx.insert_t51_lower(b1240.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1240" + ], + "range": { + "start": 107085, + "end": 107143 + } + }, + { + "id": "effect_1485", + "effect_id": "effect@107169:107220", + "bound_var": "r1242", + "source_text": "ctx.insert_t51_approx(b1234.clone(), b1241.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1234", + "b1241" + ], + "range": { + "start": 107169, + "end": 107220 + } + }, + { + "id": "effect_1486", + "effect_id": "effect@107234:107273", + "bound_var": null, + "source_text": "ctx.set_to_extract(1248, r1242.clone())", + "semantic_text": "to_extract(1248) = r1242", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1242" + ], + "range": { + "start": 107234, + "end": 107273 + } + }, + { + "id": "effect_1487", + "effect_id": "effect@107299:107346", + "bound_var": "b1243", + "source_text": "ctx.insert_t51_mul(b113.clone(), sphi2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "sphi2" + ], + "range": { + "start": 107299, + "end": 107346 + } + }, + { + "id": "effect_1488", + "effect_id": "effect@107372:107419", + "bound_var": "b1244", + "source_text": "ctx.insert_t51_mul(b119.clone(), b1237.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b119", + "b1237" + ], + "range": { + "start": 107372, + "end": 107419 + } + }, + { + "id": "effect_1489", + "effect_id": "effect@107445:107493", + "bound_var": "b1245", + "source_text": "ctx.insert_t51_add(b1243.clone(), b1244.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1243", + "b1244" + ], + "range": { + "start": 107445, + "end": 107493 + } + }, + { + "id": "effect_1490", + "effect_id": "effect@107519:107567", + "bound_var": "b1246", + "source_text": "ctx.insert_t51_mul(b1145.clone(), b1245.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1145", + "b1245" + ], + "range": { + "start": 107519, + "end": 107567 + } + }, + { + "id": "effect_1491", + "effect_id": "effect@107593:107641", + "bound_var": "b1247", + "source_text": "ctx.insert_t51_add(sphi2.clone(), b1246.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1246", + "sphi2" + ], + "range": { + "start": 107593, + "end": 107641 + } + }, + { + "id": "effect_1492", + "effect_id": "effect@107667:107715", + "bound_var": "b1248", + "source_text": "ctx.insert_t51_mul(sphi1.clone(), b1247.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1247", + "sphi1" + ], + "range": { + "start": 107667, + "end": 107715 + } + }, + { + "id": "effect_1493", + "effect_id": "effect@107741:107799", + "bound_var": "b1249", + "source_text": "ctx.insert_t51_lower(b1248.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1248" + ], + "range": { + "start": 107741, + "end": 107799 + } + }, + { + "id": "effect_1494", + "effect_id": "effect@107825:107876", + "bound_var": "r1250", + "source_text": "ctx.insert_t51_approx(b1234.clone(), b1249.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1234", + "b1249" + ], + "range": { + "start": 107825, + "end": 107876 + } + }, + { + "id": "effect_1495", + "effect_id": "effect@107890:107929", + "bound_var": null, + "source_text": "ctx.set_to_extract(1256, r1250.clone())", + "semantic_text": "to_extract(1256) = r1250", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1250" + ], + "range": { + "start": 107890, + "end": 107929 + } + }, + { + "id": "effect_1496", + "effect_id": "effect@107955:108002", + "bound_var": "b1251", + "source_text": "ctx.insert_t51_mul(b127.clone(), b1237.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1237", + "b127" + ], + "range": { + "start": 107955, + "end": 108002 + } + }, + { + "id": "effect_1497", + "effect_id": "effect@108028:108075", + "bound_var": "b1252", + "source_text": "ctx.insert_t51_mul(b119.clone(), sphi2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b119", + "sphi2" + ], + "range": { + "start": 108028, + "end": 108075 + } + }, + { + "id": "effect_1498", + "effect_id": "effect@108101:108149", + "bound_var": "b1253", + "source_text": "ctx.insert_t51_add(b1251.clone(), b1252.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1251", + "b1252" + ], + "range": { + "start": 108101, + "end": 108149 + } + }, + { + "id": "effect_1499", + "effect_id": "effect@108175:108223", + "bound_var": "b1254", + "source_text": "ctx.insert_t51_mul(b1145.clone(), b1253.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1145", + "b1253" + ], + "range": { + "start": 108175, + "end": 108223 + } + }, + { + "id": "effect_1500", + "effect_id": "effect@108249:108297", + "bound_var": "b1255", + "source_text": "ctx.insert_t51_add(b1243.clone(), b1254.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1243", + "b1254" + ], + "range": { + "start": 108249, + "end": 108297 + } + }, + { + "id": "effect_1501", + "effect_id": "effect@108323:108371", + "bound_var": "b1256", + "source_text": "ctx.insert_t51_mul(b1145.clone(), b1255.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1145", + "b1255" + ], + "range": { + "start": 108323, + "end": 108371 + } + }, + { + "id": "effect_1502", + "effect_id": "effect@108397:108445", + "bound_var": "b1257", + "source_text": "ctx.insert_t51_add(sphi2.clone(), b1256.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1256", + "sphi2" + ], + "range": { + "start": 108397, + "end": 108445 + } + }, + { + "id": "effect_1503", + "effect_id": "effect@108471:108519", + "bound_var": "b1258", + "source_text": "ctx.insert_t51_mul(sphi1.clone(), b1257.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1257", + "sphi1" + ], + "range": { + "start": 108471, + "end": 108519 + } + }, + { + "id": "effect_1504", + "effect_id": "effect@108545:108603", + "bound_var": "b1259", + "source_text": "ctx.insert_t51_lower(b1258.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1258" + ], + "range": { + "start": 108545, + "end": 108603 + } + }, + { + "id": "effect_1505", + "effect_id": "effect@108629:108680", + "bound_var": "r1260", + "source_text": "ctx.insert_t51_approx(b1234.clone(), b1259.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1234", + "b1259" + ], + "range": { + "start": 108629, + "end": 108680 + } + }, + { + "id": "effect_1506", + "effect_id": "effect@108694:108733", + "bound_var": null, + "source_text": "ctx.set_to_extract(1266, r1260.clone())", + "semantic_text": "to_extract(1266) = r1260", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1260" + ], + "range": { + "start": 108694, + "end": 108733 + } + }, + { + "id": "effect_1507", + "effect_id": "effect@108759:108815", + "bound_var": "b1261", + "source_text": "ctx.insert_t51_lower(b22.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b22" + ], + "range": { + "start": 108759, + "end": 108815 + } + }, + { + "id": "effect_1508", + "effect_id": "effect@108841:108890", + "bound_var": "r1262", + "source_text": "ctx.insert_t51_approx(b18.clone(), b1261.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1261", + "b18" + ], + "range": { + "start": 108841, + "end": 108890 + } + }, + { + "id": "effect_1509", + "effect_id": "effect@108904:108943", + "bound_var": null, + "source_text": "ctx.set_to_extract(1268, r1262.clone())", + "semantic_text": "to_extract(1268) = r1262", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1262" + ], + "range": { + "start": 108904, + "end": 108943 + } + }, + { + "id": "effect_1510", + "effect_id": "effect@108969:109015", + "bound_var": "b1263", + "source_text": "ctx.insert_t51_mul(b1145.clone(), b22.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1145", + "b22" + ], + "range": { + "start": 108969, + "end": 109015 + } + }, + { + "id": "effect_1511", + "effect_id": "effect@109041:109087", + "bound_var": "b1264", + "source_text": "ctx.insert_t51_mul(b65.clone(), b1263.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1263", + "b65" + ], + "range": { + "start": 109041, + "end": 109087 + } + }, + { + "id": "effect_1512", + "effect_id": "effect@109113:109159", + "bound_var": "b1265", + "source_text": "ctx.insert_t51_add(b1264.clone(), b22.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1264", + "b22" + ], + "range": { + "start": 109113, + "end": 109159 + } + }, + { + "id": "effect_1513", + "effect_id": "effect@109185:109243", + "bound_var": "b1266", + "source_text": "ctx.insert_t51_lower(b1265.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1265" + ], + "range": { + "start": 109185, + "end": 109243 + } + }, + { + "id": "effect_1514", + "effect_id": "effect@109269:109318", + "bound_var": "r1267", + "source_text": "ctx.insert_t51_approx(b18.clone(), b1266.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1266", + "b18" + ], + "range": { + "start": 109269, + "end": 109318 + } + }, + { + "id": "effect_1515", + "effect_id": "effect@109332:109371", + "bound_var": null, + "source_text": "ctx.set_to_extract(1273, r1267.clone())", + "semantic_text": "to_extract(1273) = r1267", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1267" + ], + "range": { + "start": 109332, + "end": 109371 + } + }, + { + "id": "effect_1516", + "effect_id": "effect@109397:109441", + "bound_var": "b1268", + "source_text": "ctx.insert_t51_mul(b65.clone(), b22.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b22", + "b65" + ], + "range": { + "start": 109397, + "end": 109441 + } + }, + { + "id": "effect_1517", + "effect_id": "effect@109467:109513", + "bound_var": "b1269", + "source_text": "ctx.insert_t51_mul(b96.clone(), b1263.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1263", + "b96" + ], + "range": { + "start": 109467, + "end": 109513 + } + }, + { + "id": "effect_1518", + "effect_id": "effect@109539:109587", + "bound_var": "b1270", + "source_text": "ctx.insert_t51_add(b1268.clone(), b1269.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1268", + "b1269" + ], + "range": { + "start": 109539, + "end": 109587 + } + }, + { + "id": "effect_1519", + "effect_id": "effect@109613:109661", + "bound_var": "b1271", + "source_text": "ctx.insert_t51_mul(b1145.clone(), b1270.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1145", + "b1270" + ], + "range": { + "start": 109613, + "end": 109661 + } + }, + { + "id": "effect_1520", + "effect_id": "effect@109687:109733", + "bound_var": "b1272", + "source_text": "ctx.insert_t51_add(b22.clone(), b1271.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1271", + "b22" + ], + "range": { + "start": 109687, + "end": 109733 + } + }, + { + "id": "effect_1521", + "effect_id": "effect@109759:109817", + "bound_var": "b1273", + "source_text": "ctx.insert_t51_lower(b1272.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1272" + ], + "range": { + "start": 109759, + "end": 109817 + } + }, + { + "id": "effect_1522", + "effect_id": "effect@109843:109892", + "bound_var": "r1274", + "source_text": "ctx.insert_t51_approx(b18.clone(), b1273.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1273", + "b18" + ], + "range": { + "start": 109843, + "end": 109892 + } + }, + { + "id": "effect_1523", + "effect_id": "effect@109906:109945", + "bound_var": null, + "source_text": "ctx.set_to_extract(1280, r1274.clone())", + "semantic_text": "to_extract(1280) = r1274", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1274" + ], + "range": { + "start": 109906, + "end": 109945 + } + }, + { + "id": "effect_1524", + "effect_id": "effect@109971:110018", + "bound_var": "b1275", + "source_text": "ctx.insert_t51_mul(b104.clone(), b1263.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b104", + "b1263" + ], + "range": { + "start": 109971, + "end": 110018 + } + }, + { + "id": "effect_1525", + "effect_id": "effect@110044:110088", + "bound_var": "b1276", + "source_text": "ctx.insert_t51_mul(b96.clone(), b22.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b22", + "b96" + ], + "range": { + "start": 110044, + "end": 110088 + } + }, + { + "id": "effect_1526", + "effect_id": "effect@110114:110162", + "bound_var": "b1277", + "source_text": "ctx.insert_t51_add(b1275.clone(), b1276.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1275", + "b1276" + ], + "range": { + "start": 110114, + "end": 110162 + } + }, + { + "id": "effect_1527", + "effect_id": "effect@110188:110236", + "bound_var": "b1278", + "source_text": "ctx.insert_t51_mul(b1145.clone(), b1277.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1145", + "b1277" + ], + "range": { + "start": 110188, + "end": 110236 + } + }, + { + "id": "effect_1528", + "effect_id": "effect@110262:110310", + "bound_var": "b1279", + "source_text": "ctx.insert_t51_add(b1268.clone(), b1278.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1268", + "b1278" + ], + "range": { + "start": 110262, + "end": 110310 + } + }, + { + "id": "effect_1529", + "effect_id": "effect@110336:110384", + "bound_var": "b1280", + "source_text": "ctx.insert_t51_mul(b1145.clone(), b1279.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1145", + "b1279" + ], + "range": { + "start": 110336, + "end": 110384 + } + }, + { + "id": "effect_1530", + "effect_id": "effect@110410:110456", + "bound_var": "b1281", + "source_text": "ctx.insert_t51_add(b22.clone(), b1280.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1280", + "b22" + ], + "range": { + "start": 110410, + "end": 110456 + } + }, + { + "id": "effect_1531", + "effect_id": "effect@110482:110540", + "bound_var": "b1282", + "source_text": "ctx.insert_t51_lower(b1281.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1281" + ], + "range": { + "start": 110482, + "end": 110540 + } + }, + { + "id": "effect_1532", + "effect_id": "effect@110566:110615", + "bound_var": "r1283", + "source_text": "ctx.insert_t51_approx(b18.clone(), b1282.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1282", + "b18" + ], + "range": { + "start": 110566, + "end": 110615 + } + }, + { + "id": "effect_1533", + "effect_id": "effect@110629:110668", + "bound_var": null, + "source_text": "ctx.set_to_extract(1289, r1283.clone())", + "semantic_text": "to_extract(1289) = r1283", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1283" + ], + "range": { + "start": 110629, + "end": 110668 + } + }, + { + "id": "effect_1534", + "effect_id": "effect@110694:110739", + "bound_var": "b1284", + "source_text": "ctx.insert_t51_add(b279.clone(), b40.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b279", + "b40" + ], + "range": { + "start": 110694, + "end": 110739 + } + }, + { + "id": "effect_1535", + "effect_id": "effect@110765:110823", + "bound_var": "b1285", + "source_text": "ctx.insert_t51_lower(b1284.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1284" + ], + "range": { + "start": 110765, + "end": 110823 + } + }, + { + "id": "effect_1536", + "effect_id": "effect@110849:110898", + "bound_var": "r1286", + "source_text": "ctx.insert_t51_approx(b42.clone(), b1285.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1285", + "b42" + ], + "range": { + "start": 110849, + "end": 110898 + } + }, + { + "id": "effect_1537", + "effect_id": "effect@110912:110951", + "bound_var": null, + "source_text": "ctx.set_to_extract(1292, r1286.clone())", + "semantic_text": "to_extract(1292) = r1286", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1286" + ], + "range": { + "start": 110912, + "end": 110951 + } + }, + { + "id": "effect_1538", + "effect_id": "effect@110977:111023", + "bound_var": "b1287", + "source_text": "ctx.insert_t51_mul(sphi1.clone(), b40.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b40", + "sphi1" + ], + "range": { + "start": 110977, + "end": 111023 + } + }, + { + "id": "effect_1539", + "effect_id": "effect@111049:111095", + "bound_var": "b1288", + "source_text": "ctx.insert_t51_mul(b65.clone(), b1287.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1287", + "b65" + ], + "range": { + "start": 111049, + "end": 111095 + } + }, + { + "id": "effect_1540", + "effect_id": "effect@111121:111166", + "bound_var": "b1289", + "source_text": "ctx.insert_t51_add(b9.clone(), b1288.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1288", + "b9" + ], + "range": { + "start": 111121, + "end": 111166 + } + }, + { + "id": "effect_1541", + "effect_id": "effect@111192:111240", + "bound_var": "b1290", + "source_text": "ctx.insert_t51_mul(sphi1.clone(), b1289.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1289", + "sphi1" + ], + "range": { + "start": 111192, + "end": 111240 + } + }, + { + "id": "effect_1542", + "effect_id": "effect@111266:111312", + "bound_var": "b1291", + "source_text": "ctx.insert_t51_add(b1290.clone(), b40.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1290", + "b40" + ], + "range": { + "start": 111266, + "end": 111312 + } + }, + { + "id": "effect_1543", + "effect_id": "effect@111338:111396", + "bound_var": "b1292", + "source_text": "ctx.insert_t51_lower(b1291.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1291" + ], + "range": { + "start": 111338, + "end": 111396 + } + }, + { + "id": "effect_1544", + "effect_id": "effect@111422:111471", + "bound_var": "r1293", + "source_text": "ctx.insert_t51_approx(b42.clone(), b1292.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1292", + "b42" + ], + "range": { + "start": 111422, + "end": 111471 + } + }, + { + "id": "effect_1545", + "effect_id": "effect@111485:111524", + "bound_var": null, + "source_text": "ctx.set_to_extract(1299, r1293.clone())", + "semantic_text": "to_extract(1299) = r1293", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1293" + ], + "range": { + "start": 111485, + "end": 111524 + } + }, + { + "id": "effect_1546", + "effect_id": "effect@111550:111594", + "bound_var": "b1294", + "source_text": "ctx.insert_t51_mul(b65.clone(), b40.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b40", + "b65" + ], + "range": { + "start": 111550, + "end": 111594 + } + }, + { + "id": "effect_1547", + "effect_id": "effect@111620:111666", + "bound_var": "b1295", + "source_text": "ctx.insert_t51_mul(b113.clone(), b279.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b279" + ], + "range": { + "start": 111620, + "end": 111666 + } + }, + { + "id": "effect_1548", + "effect_id": "effect@111692:111740", + "bound_var": "b1296", + "source_text": "ctx.insert_t51_add(b1294.clone(), b1295.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1294", + "b1295" + ], + "range": { + "start": 111692, + "end": 111740 + } + }, + { + "id": "effect_1549", + "effect_id": "effect@111766:111814", + "bound_var": "b1297", + "source_text": "ctx.insert_t51_mul(sphi1.clone(), b1296.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1296", + "sphi1" + ], + "range": { + "start": 111766, + "end": 111814 + } + }, + { + "id": "effect_1550", + "effect_id": "effect@111840:111885", + "bound_var": "b1298", + "source_text": "ctx.insert_t51_add(b9.clone(), b1297.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1297", + "b9" + ], + "range": { + "start": 111840, + "end": 111885 + } + }, + { + "id": "effect_1551", + "effect_id": "effect@111911:111959", + "bound_var": "b1299", + "source_text": "ctx.insert_t51_mul(sphi1.clone(), b1298.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1298", + "sphi1" + ], + "range": { + "start": 111911, + "end": 111959 + } + }, + { + "id": "effect_1552", + "effect_id": "effect@111985:112031", + "bound_var": "b1300", + "source_text": "ctx.insert_t51_add(b1299.clone(), b40.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1299", + "b40" + ], + "range": { + "start": 111985, + "end": 112031 + } + }, + { + "id": "effect_1553", + "effect_id": "effect@112057:112115", + "bound_var": "b1301", + "source_text": "ctx.insert_t51_lower(b1300.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1300" + ], + "range": { + "start": 112057, + "end": 112115 + } + }, + { + "id": "effect_1554", + "effect_id": "effect@112141:112190", + "bound_var": "r1302", + "source_text": "ctx.insert_t51_approx(b42.clone(), b1301.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1301", + "b42" + ], + "range": { + "start": 112141, + "end": 112190 + } + }, + { + "id": "effect_1555", + "effect_id": "effect@112204:112243", + "bound_var": null, + "source_text": "ctx.set_to_extract(1308, r1302.clone())", + "semantic_text": "to_extract(1308) = r1302", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1302" + ], + "range": { + "start": 112204, + "end": 112243 + } + }, + { + "id": "effect_1556", + "effect_id": "effect@112269:112315", + "bound_var": "b1303", + "source_text": "ctx.insert_t51_mul(sphi1.clone(), b22.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b22", + "sphi1" + ], + "range": { + "start": 112269, + "end": 112315 + } + }, + { + "id": "effect_1557", + "effect_id": "effect@112341:112387", + "bound_var": "b1304", + "source_text": "ctx.insert_t51_mul(b65.clone(), b1303.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1303", + "b65" + ], + "range": { + "start": 112341, + "end": 112387 + } + }, + { + "id": "effect_1558", + "effect_id": "effect@112413:112458", + "bound_var": "b1305", + "source_text": "ctx.insert_t51_add(b9.clone(), b1304.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1304", + "b9" + ], + "range": { + "start": 112413, + "end": 112458 + } + }, + { + "id": "effect_1559", + "effect_id": "effect@112484:112532", + "bound_var": "b1306", + "source_text": "ctx.insert_t51_mul(sphi1.clone(), b1305.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1305", + "sphi1" + ], + "range": { + "start": 112484, + "end": 112532 + } + }, + { + "id": "effect_1560", + "effect_id": "effect@112558:112604", + "bound_var": "b1307", + "source_text": "ctx.insert_t51_add(b1306.clone(), b22.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1306", + "b22" + ], + "range": { + "start": 112558, + "end": 112604 + } + }, + { + "id": "effect_1561", + "effect_id": "effect@112630:112688", + "bound_var": "b1308", + "source_text": "ctx.insert_t51_lower(b1307.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1307" + ], + "range": { + "start": 112630, + "end": 112688 + } + }, + { + "id": "effect_1562", + "effect_id": "effect@112714:112763", + "bound_var": "r1309", + "source_text": "ctx.insert_t51_approx(b19.clone(), b1308.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1308", + "b19" + ], + "range": { + "start": 112714, + "end": 112763 + } + }, + { + "id": "effect_1563", + "effect_id": "effect@112777:112816", + "bound_var": null, + "source_text": "ctx.set_to_extract(1315, r1309.clone())", + "semantic_text": "to_extract(1315) = r1309", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1309" + ], + "range": { + "start": 112777, + "end": 112816 + } + }, + { + "id": "effect_1564", + "effect_id": "effect@112842:112890", + "bound_var": "b1310", + "source_text": "ctx.insert_t51_add(b1268.clone(), b1295.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1268", + "b1295" + ], + "range": { + "start": 112842, + "end": 112890 + } + }, + { + "id": "effect_1565", + "effect_id": "effect@112916:112964", + "bound_var": "b1311", + "source_text": "ctx.insert_t51_mul(sphi1.clone(), b1310.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1310", + "sphi1" + ], + "range": { + "start": 112916, + "end": 112964 + } + }, + { + "id": "effect_1566", + "effect_id": "effect@112990:113035", + "bound_var": "b1312", + "source_text": "ctx.insert_t51_add(b9.clone(), b1311.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1311", + "b9" + ], + "range": { + "start": 112990, + "end": 113035 + } + }, + { + "id": "effect_1567", + "effect_id": "effect@113061:113109", + "bound_var": "b1313", + "source_text": "ctx.insert_t51_mul(sphi1.clone(), b1312.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1312", + "sphi1" + ], + "range": { + "start": 113061, + "end": 113109 + } + }, + { + "id": "effect_1568", + "effect_id": "effect@113135:113181", + "bound_var": "b1314", + "source_text": "ctx.insert_t51_add(b1313.clone(), b22.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1313", + "b22" + ], + "range": { + "start": 113135, + "end": 113181 + } + }, + { + "id": "effect_1569", + "effect_id": "effect@113207:113265", + "bound_var": "b1315", + "source_text": "ctx.insert_t51_lower(b1314.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1314" + ], + "range": { + "start": 113207, + "end": 113265 + } + }, + { + "id": "effect_1570", + "effect_id": "effect@113291:113340", + "bound_var": "r1316", + "source_text": "ctx.insert_t51_approx(b19.clone(), b1315.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1315", + "b19" + ], + "range": { + "start": 113291, + "end": 113340 + } + }, + { + "id": "effect_1571", + "effect_id": "effect@113354:113393", + "bound_var": null, + "source_text": "ctx.set_to_extract(1322, r1316.clone())", + "semantic_text": "to_extract(1322) = r1316", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1316" + ], + "range": { + "start": 113354, + "end": 113393 + } + }, + { + "id": "effect_1572", + "effect_id": "effect@113419:113474", + "bound_var": "b1317", + "source_text": "ctx.insert_t51_lower(b7.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b7" + ], + "range": { + "start": 113419, + "end": 113474 + } + }, + { + "id": "effect_1573", + "effect_id": "effect@113500:113548", + "bound_var": "r1318", + "source_text": "ctx.insert_t51_approx(b7.clone(), b1317.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1317", + "b7" + ], + "range": { + "start": 113500, + "end": 113548 + } + }, + { + "id": "effect_1574", + "effect_id": "effect@113562:113601", + "bound_var": null, + "source_text": "ctx.set_to_extract(1324, r1318.clone())", + "semantic_text": "to_extract(1324) = r1318", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1318" + ], + "range": { + "start": 113562, + "end": 113601 + } + }, + { + "id": "effect_1575", + "effect_id": "effect@113627:113683", + "bound_var": "b1319", + "source_text": "ctx.insert_t51_lower(b10.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b10" + ], + "range": { + "start": 113627, + "end": 113683 + } + }, + { + "id": "effect_1576", + "effect_id": "effect@113709:113758", + "bound_var": "r1320", + "source_text": "ctx.insert_t51_approx(b10.clone(), b1319.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b10", + "b1319" + ], + "range": { + "start": 113709, + "end": 113758 + } + }, + { + "id": "effect_1577", + "effect_id": "effect@113772:113811", + "bound_var": null, + "source_text": "ctx.set_to_extract(1326, r1320.clone())", + "semantic_text": "to_extract(1326) = r1320", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1320" + ], + "range": { + "start": 113772, + "end": 113811 + } + }, + { + "id": "effect_1578", + "effect_id": "effect@113837:113893", + "bound_var": "b1321", + "source_text": "ctx.insert_t51_lower(b11.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b11" + ], + "range": { + "start": 113837, + "end": 113893 + } + }, + { + "id": "effect_1579", + "effect_id": "effect@113919:113968", + "bound_var": "r1322", + "source_text": "ctx.insert_t51_approx(b11.clone(), b1321.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b11", + "b1321" + ], + "range": { + "start": 113919, + "end": 113968 + } + }, + { + "id": "effect_1580", + "effect_id": "effect@113982:114021", + "bound_var": null, + "source_text": "ctx.set_to_extract(1328, r1322.clone())", + "semantic_text": "to_extract(1328) = r1322", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1322" + ], + "range": { + "start": 113982, + "end": 114021 + } + }, + { + "id": "effect_1581", + "effect_id": "effect@114047:114103", + "bound_var": "b1323", + "source_text": "ctx.insert_t51_lower(b13.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b13" + ], + "range": { + "start": 114047, + "end": 114103 + } + }, + { + "id": "effect_1582", + "effect_id": "effect@114129:114178", + "bound_var": "r1324", + "source_text": "ctx.insert_t51_approx(b13.clone(), b1323.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b13", + "b1323" + ], + "range": { + "start": 114129, + "end": 114178 + } + }, + { + "id": "effect_1583", + "effect_id": "effect@114192:114231", + "bound_var": null, + "source_text": "ctx.set_to_extract(1330, r1324.clone())", + "semantic_text": "to_extract(1330) = r1324", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1324" + ], + "range": { + "start": 114192, + "end": 114231 + } + }, + { + "id": "effect_1584", + "effect_id": "effect@114257:114315", + "bound_var": "b1325", + "source_text": "ctx.insert_t51_lower(b1234.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1234" + ], + "range": { + "start": 114257, + "end": 114315 + } + }, + { + "id": "effect_1585", + "effect_id": "effect@114341:114392", + "bound_var": "r1326", + "source_text": "ctx.insert_t51_approx(b1234.clone(), b1325.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1234", + "b1325" + ], + "range": { + "start": 114341, + "end": 114392 + } + }, + { + "id": "effect_1586", + "effect_id": "effect@114406:114445", + "bound_var": null, + "source_text": "ctx.set_to_extract(1332, r1326.clone())", + "semantic_text": "to_extract(1332) = r1326", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1326" + ], + "range": { + "start": 114406, + "end": 114445 + } + }, + { + "id": "effect_1587", + "effect_id": "effect@114471:114517", + "bound_var": "b1327", + "source_text": "ctx.insert_t51_div(b17.clone(), sphi1.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b17", + "sphi1" + ], + "range": { + "start": 114471, + "end": 114517 + } + }, + { + "id": "effect_1588", + "effect_id": "effect@114543:114591", + "bound_var": "b1328", + "source_text": "ctx.insert_t51_add(sphi2.clone(), b1327.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1327", + "sphi2" + ], + "range": { + "start": 114543, + "end": 114591 + } + }, + { + "id": "effect_1589", + "effect_id": "effect@114617:114665", + "bound_var": "b1329", + "source_text": "ctx.insert_t51_mul(sphi1.clone(), b1328.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1328", + "sphi1" + ], + "range": { + "start": 114617, + "end": 114665 + } + }, + { + "id": "effect_1590", + "effect_id": "effect@114691:114749", + "bound_var": "b1330", + "source_text": "ctx.insert_t51_lower(b1329.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1329" + ], + "range": { + "start": 114691, + "end": 114749 + } + }, + { + "id": "effect_1591", + "effect_id": "effect@114775:114825", + "bound_var": "r1331", + "source_text": "ctx.insert_t51_approx(b263.clone(), b1330.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1330", + "b263" + ], + "range": { + "start": 114775, + "end": 114825 + } + }, + { + "id": "effect_1592", + "effect_id": "effect@114839:114878", + "bound_var": null, + "source_text": "ctx.set_to_extract(1337, r1331.clone())", + "semantic_text": "to_extract(1337) = r1331", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1331" + ], + "range": { + "start": 114839, + "end": 114878 + } + }, + { + "id": "effect_1593", + "effect_id": "effect@114904:114950", + "bound_var": "b1332", + "source_text": "ctx.insert_t51_div(b22.clone(), sphi1.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b22", + "sphi1" + ], + "range": { + "start": 114904, + "end": 114950 + } + }, + { + "id": "effect_1594", + "effect_id": "effect@114976:115021", + "bound_var": "b1333", + "source_text": "ctx.insert_t51_add(b9.clone(), b1332.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1332", + "b9" + ], + "range": { + "start": 114976, + "end": 115021 + } + }, + { + "id": "effect_1595", + "effect_id": "effect@115047:115095", + "bound_var": "b1334", + "source_text": "ctx.insert_t51_mul(sphi1.clone(), b1333.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1333", + "sphi1" + ], + "range": { + "start": 115047, + "end": 115095 + } + }, + { + "id": "effect_1596", + "effect_id": "effect@115121:115179", + "bound_var": "b1335", + "source_text": "ctx.insert_t51_lower(b1334.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1334" + ], + "range": { + "start": 115121, + "end": 115179 + } + }, + { + "id": "effect_1597", + "effect_id": "effect@115205:115255", + "bound_var": "r1336", + "source_text": "ctx.insert_t51_approx(b280.clone(), b1335.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1335", + "b280" + ], + "range": { + "start": 115205, + "end": 115255 + } + }, + { + "id": "effect_1598", + "effect_id": "effect@115269:115308", + "bound_var": null, + "source_text": "ctx.set_to_extract(1342, r1336.clone())", + "semantic_text": "to_extract(1342) = r1336", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1336" + ], + "range": { + "start": 115269, + "end": 115308 + } + }, + { + "id": "effect_1599", + "effect_id": "effect@115334:115381", + "bound_var": "b1337", + "source_text": "ctx.insert_t51_div(b528.clone(), sphi1.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b528", + "sphi1" + ], + "range": { + "start": 115334, + "end": 115381 + } + }, + { + "id": "effect_1600", + "effect_id": "effect@115407:115453", + "bound_var": "b1338", + "source_text": "ctx.insert_t51_mul(b98.clone(), b1337.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1337", + "b98" + ], + "range": { + "start": 115407, + "end": 115453 + } + }, + { + "id": "effect_1601", + "effect_id": "effect@115479:115524", + "bound_var": "b1339", + "source_text": "ctx.insert_t51_add(b9.clone(), b1338.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1338", + "b9" + ], + "range": { + "start": 115479, + "end": 115524 + } + }, + { + "id": "effect_1602", + "effect_id": "effect@115550:115598", + "bound_var": "b1340", + "source_text": "ctx.insert_t51_mul(sphi1.clone(), b1339.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1339", + "sphi1" + ], + "range": { + "start": 115550, + "end": 115598 + } + }, + { + "id": "effect_1603", + "effect_id": "effect@115624:115682", + "bound_var": "b1341", + "source_text": "ctx.insert_t51_lower(b1340.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1340" + ], + "range": { + "start": 115624, + "end": 115682 + } + }, + { + "id": "effect_1604", + "effect_id": "effect@115708:115758", + "bound_var": "r1342", + "source_text": "ctx.insert_t51_approx(b440.clone(), b1341.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1341", + "b440" + ], + "range": { + "start": 115708, + "end": 115758 + } + }, + { + "id": "effect_1605", + "effect_id": "effect@115772:115811", + "bound_var": null, + "source_text": "ctx.set_to_extract(1348, r1342.clone())", + "semantic_text": "to_extract(1348) = r1342", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1342" + ], + "range": { + "start": 115772, + "end": 115811 + } + }, + { + "id": "effect_1606", + "effect_id": "effect@115837:115883", + "bound_var": "b1343", + "source_text": "ctx.insert_t51_mul(b49.clone(), sphi2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b49", + "sphi2" + ], + "range": { + "start": 115837, + "end": 115883 + } + }, + { + "id": "effect_1607", + "effect_id": "effect@115909:115955", + "bound_var": "b1344", + "source_text": "ctx.insert_t51_mul(b49.clone(), b1327.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1327", + "b49" + ], + "range": { + "start": 115909, + "end": 115955 + } + }, + { + "id": "effect_1608", + "effect_id": "effect@115981:116029", + "bound_var": "b1345", + "source_text": "ctx.insert_t51_add(b1343.clone(), b1344.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1343", + "b1344" + ], + "range": { + "start": 115981, + "end": 116029 + } + }, + { + "id": "effect_1609", + "effect_id": "effect@116055:116103", + "bound_var": "b1346", + "source_text": "ctx.insert_t51_mul(sphi1.clone(), b1345.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1345", + "sphi1" + ], + "range": { + "start": 116055, + "end": 116103 + } + }, + { + "id": "effect_1610", + "effect_id": "effect@116129:116175", + "bound_var": "b1347", + "source_text": "ctx.insert_t51_mul(b49.clone(), b1346.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1346", + "b49" + ], + "range": { + "start": 116129, + "end": 116175 + } + }, + { + "id": "effect_1611", + "effect_id": "effect@116201:116259", + "bound_var": "b1348", + "source_text": "ctx.insert_t51_lower(b1347.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1347" + ], + "range": { + "start": 116201, + "end": 116259 + } + }, + { + "id": "effect_1612", + "effect_id": "effect@116285:116335", + "bound_var": "r1349", + "source_text": "ctx.insert_t51_approx(b263.clone(), b1348.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1348", + "b263" + ], + "range": { + "start": 116285, + "end": 116335 + } + }, + { + "id": "effect_1613", + "effect_id": "effect@116349:116388", + "bound_var": null, + "source_text": "ctx.set_to_extract(1355, r1349.clone())", + "semantic_text": "to_extract(1355) = r1349", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1349" + ], + "range": { + "start": 116349, + "end": 116388 + } + }, + { + "id": "effect_1614", + "effect_id": "effect@116414:116457", + "bound_var": "b1350", + "source_text": "ctx.insert_t51_mul(b49.clone(), b9.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b49", + "b9" + ], + "range": { + "start": 116414, + "end": 116457 + } + }, + { + "id": "effect_1615", + "effect_id": "effect@116483:116529", + "bound_var": "b1351", + "source_text": "ctx.insert_t51_mul(b49.clone(), b1332.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1332", + "b49" + ], + "range": { + "start": 116483, + "end": 116529 + } + }, + { + "id": "effect_1616", + "effect_id": "effect@116555:116603", + "bound_var": "b1352", + "source_text": "ctx.insert_t51_add(b1350.clone(), b1351.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1350", + "b1351" + ], + "range": { + "start": 116555, + "end": 116603 + } + }, + { + "id": "effect_1617", + "effect_id": "effect@116629:116677", + "bound_var": "b1353", + "source_text": "ctx.insert_t51_mul(sphi1.clone(), b1352.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1352", + "sphi1" + ], + "range": { + "start": 116629, + "end": 116677 + } + }, + { + "id": "effect_1618", + "effect_id": "effect@116703:116749", + "bound_var": "b1354", + "source_text": "ctx.insert_t51_mul(b49.clone(), b1353.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1353", + "b49" + ], + "range": { + "start": 116703, + "end": 116749 + } + }, + { + "id": "effect_1619", + "effect_id": "effect@116775:116833", + "bound_var": "b1355", + "source_text": "ctx.insert_t51_lower(b1354.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1354" + ], + "range": { + "start": 116775, + "end": 116833 + } + }, + { + "id": "effect_1620", + "effect_id": "effect@116859:116909", + "bound_var": "r1356", + "source_text": "ctx.insert_t51_approx(b280.clone(), b1355.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1355", + "b280" + ], + "range": { + "start": 116859, + "end": 116909 + } + }, + { + "id": "effect_1621", + "effect_id": "effect@116923:116962", + "bound_var": null, + "source_text": "ctx.set_to_extract(1362, r1356.clone())", + "semantic_text": "to_extract(1362) = r1356", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1356" + ], + "range": { + "start": 116923, + "end": 116962 + } + }, + { + "id": "effect_1622", + "effect_id": "effect@116988:117034", + "bound_var": "b1357", + "source_text": "ctx.insert_t51_mul(b65.clone(), b1337.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1337", + "b65" + ], + "range": { + "start": 116988, + "end": 117034 + } + }, + { + "id": "effect_1623", + "effect_id": "effect@117060:117108", + "bound_var": "b1358", + "source_text": "ctx.insert_t51_add(b1350.clone(), b1357.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1350", + "b1357" + ], + "range": { + "start": 117060, + "end": 117108 + } + }, + { + "id": "effect_1624", + "effect_id": "effect@117134:117182", + "bound_var": "b1359", + "source_text": "ctx.insert_t51_mul(sphi1.clone(), b1358.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1358", + "sphi1" + ], + "range": { + "start": 117134, + "end": 117182 + } + }, + { + "id": "effect_1625", + "effect_id": "effect@117208:117254", + "bound_var": "b1360", + "source_text": "ctx.insert_t51_mul(b49.clone(), b1359.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1359", + "b49" + ], + "range": { + "start": 117208, + "end": 117254 + } + }, + { + "id": "effect_1626", + "effect_id": "effect@117280:117338", + "bound_var": "b1361", + "source_text": "ctx.insert_t51_lower(b1360.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1360" + ], + "range": { + "start": 117280, + "end": 117338 + } + }, + { + "id": "effect_1627", + "effect_id": "effect@117364:117414", + "bound_var": "r1362", + "source_text": "ctx.insert_t51_approx(b440.clone(), b1361.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1361", + "b440" + ], + "range": { + "start": 117364, + "end": 117414 + } + }, + { + "id": "effect_1628", + "effect_id": "effect@117428:117467", + "bound_var": null, + "source_text": "ctx.set_to_extract(1368, r1362.clone())", + "semantic_text": "to_extract(1368) = r1362", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1362" + ], + "range": { + "start": 117428, + "end": 117467 + } + }, + { + "id": "effect_1629", + "effect_id": "effect@117493:117551", + "bound_var": "b1363", + "source_text": "ctx.insert_t51_lower(sphi2.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "sphi2" + ], + "range": { + "start": 117493, + "end": 117551 + } + }, + { + "id": "effect_1630", + "effect_id": "effect@117577:117628", + "bound_var": "r1364", + "source_text": "ctx.insert_t51_approx(sphi2.clone(), b1363.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1363", + "sphi2" + ], + "range": { + "start": 117577, + "end": 117628 + } + }, + { + "id": "effect_1631", + "effect_id": "effect@117642:117681", + "bound_var": null, + "source_text": "ctx.set_to_extract(1370, r1364.clone())", + "semantic_text": "to_extract(1370) = r1364", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1364" + ], + "range": { + "start": 117642, + "end": 117681 + } + }, + { + "id": "effect_1632", + "effect_id": "effect@117707:117753", + "bound_var": "b1365", + "source_text": "ctx.insert_t51_pow(sphi2.clone(), b90.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b90", + "sphi2" + ], + "range": { + "start": 117707, + "end": 117753 + } + }, + { + "id": "effect_1633", + "effect_id": "effect@117779:117826", + "bound_var": "b1366", + "source_text": "ctx.insert_t51_mul(b113.clone(), b1365.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b1365" + ], + "range": { + "start": 117779, + "end": 117826 + } + }, + { + "id": "effect_1634", + "effect_id": "effect@117852:117898", + "bound_var": "b1367", + "source_text": "ctx.insert_t51_add(b87.clone(), b1366.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1366", + "b87" + ], + "range": { + "start": 117852, + "end": 117898 + } + }, + { + "id": "effect_1635", + "effect_id": "effect@117924:117972", + "bound_var": "b1368", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1367.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1367", + "sphi2" + ], + "range": { + "start": 117924, + "end": 117972 + } + }, + { + "id": "effect_1636", + "effect_id": "effect@117998:118056", + "bound_var": "b1369", + "source_text": "ctx.insert_t51_lower(b1368.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1368" + ], + "range": { + "start": 117998, + "end": 118056 + } + }, + { + "id": "effect_1637", + "effect_id": "effect@118082:118130", + "bound_var": "r1370", + "source_text": "ctx.insert_t51_approx(b9.clone(), b1369.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1369", + "b9" + ], + "range": { + "start": 118082, + "end": 118130 + } + }, + { + "id": "effect_1638", + "effect_id": "effect@118144:118183", + "bound_var": null, + "source_text": "ctx.set_to_extract(1376, r1370.clone())", + "semantic_text": "to_extract(1376) = r1370", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1370" + ], + "range": { + "start": 118144, + "end": 118183 + } + }, + { + "id": "effect_1639", + "effect_id": "effect@118209:118256", + "bound_var": "b1371", + "source_text": "ctx.insert_t51_mul(b119.clone(), b1365.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b119", + "b1365" + ], + "range": { + "start": 118209, + "end": 118256 + } + }, + { + "id": "effect_1640", + "effect_id": "effect@118282:118328", + "bound_var": "b1372", + "source_text": "ctx.insert_t51_sub(b1371.clone(), b74.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1371", + "b74" + ], + "range": { + "start": 118282, + "end": 118328 + } + }, + { + "id": "effect_1641", + "effect_id": "effect@118354:118402", + "bound_var": "b1373", + "source_text": "ctx.insert_t51_mul(b1365.clone(), b1372.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1365", + "b1372" + ], + "range": { + "start": 118354, + "end": 118402 + } + }, + { + "id": "effect_1642", + "effect_id": "effect@118428:118474", + "bound_var": "b1374", + "source_text": "ctx.insert_t51_add(b87.clone(), b1373.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1373", + "b87" + ], + "range": { + "start": 118428, + "end": 118474 + } + }, + { + "id": "effect_1643", + "effect_id": "effect@118500:118548", + "bound_var": "b1375", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1374.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1374", + "sphi2" + ], + "range": { + "start": 118500, + "end": 118548 + } + }, + { + "id": "effect_1644", + "effect_id": "effect@118574:118632", + "bound_var": "b1376", + "source_text": "ctx.insert_t51_lower(b1375.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1375" + ], + "range": { + "start": 118574, + "end": 118632 + } + }, + { + "id": "effect_1645", + "effect_id": "effect@118658:118706", + "bound_var": "r1377", + "source_text": "ctx.insert_t51_approx(b9.clone(), b1376.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1376", + "b9" + ], + "range": { + "start": 118658, + "end": 118706 + } + }, + { + "id": "effect_1646", + "effect_id": "effect@118720:118759", + "bound_var": null, + "source_text": "ctx.set_to_extract(1383, r1377.clone())", + "semantic_text": "to_extract(1383) = r1377", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1377" + ], + "range": { + "start": 118720, + "end": 118759 + } + }, + { + "id": "effect_1647", + "effect_id": "effect@118785:118832", + "bound_var": "b1378", + "source_text": "ctx.insert_t51_mul(b127.clone(), b1365.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b127", + "b1365" + ], + "range": { + "start": 118785, + "end": 118832 + } + }, + { + "id": "effect_1648", + "effect_id": "effect@118858:118905", + "bound_var": "b1379", + "source_text": "ctx.insert_t51_add(b119.clone(), b1378.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b119", + "b1378" + ], + "range": { + "start": 118858, + "end": 118905 + } + }, + { + "id": "effect_1649", + "effect_id": "effect@118931:118979", + "bound_var": "b1380", + "source_text": "ctx.insert_t51_mul(b1365.clone(), b1379.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1365", + "b1379" + ], + "range": { + "start": 118931, + "end": 118979 + } + }, + { + "id": "effect_1650", + "effect_id": "effect@119005:119051", + "bound_var": "b1381", + "source_text": "ctx.insert_t51_sub(b1380.clone(), b74.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1380", + "b74" + ], + "range": { + "start": 119005, + "end": 119051 + } + }, + { + "id": "effect_1651", + "effect_id": "effect@119077:119125", + "bound_var": "b1382", + "source_text": "ctx.insert_t51_mul(b1365.clone(), b1381.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1365", + "b1381" + ], + "range": { + "start": 119077, + "end": 119125 + } + }, + { + "id": "effect_1652", + "effect_id": "effect@119151:119197", + "bound_var": "b1383", + "source_text": "ctx.insert_t51_add(b87.clone(), b1382.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1382", + "b87" + ], + "range": { + "start": 119151, + "end": 119197 + } + }, + { + "id": "effect_1653", + "effect_id": "effect@119223:119271", + "bound_var": "b1384", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1383.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1383", + "sphi2" + ], + "range": { + "start": 119223, + "end": 119271 + } + }, + { + "id": "effect_1654", + "effect_id": "effect@119297:119355", + "bound_var": "b1385", + "source_text": "ctx.insert_t51_lower(b1384.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1384" + ], + "range": { + "start": 119297, + "end": 119355 + } + }, + { + "id": "effect_1655", + "effect_id": "effect@119381:119429", + "bound_var": "r1386", + "source_text": "ctx.insert_t51_approx(b9.clone(), b1385.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1385", + "b9" + ], + "range": { + "start": 119381, + "end": 119429 + } + }, + { + "id": "effect_1656", + "effect_id": "effect@119443:119482", + "bound_var": null, + "source_text": "ctx.set_to_extract(1392, r1386.clone())", + "semantic_text": "to_extract(1392) = r1386", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1386" + ], + "range": { + "start": 119443, + "end": 119482 + } + }, + { + "id": "effect_1657", + "effect_id": "effect@119508:119553", + "bound_var": "b1387", + "source_text": "ctx.insert_t51_mul(b1365.clone(), b7.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1365", + "b7" + ], + "range": { + "start": 119508, + "end": 119553 + } + }, + { + "id": "effect_1658", + "effect_id": "effect@119579:119626", + "bound_var": "b1388", + "source_text": "ctx.insert_t51_mul(b113.clone(), b1387.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b1387" + ], + "range": { + "start": 119579, + "end": 119626 + } + }, + { + "id": "effect_1659", + "effect_id": "effect@119652:119697", + "bound_var": "b1389", + "source_text": "ctx.insert_t51_add(b7.clone(), b1388.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1388", + "b7" + ], + "range": { + "start": 119652, + "end": 119697 + } + }, + { + "id": "effect_1660", + "effect_id": "effect@119723:119771", + "bound_var": "b1390", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1389.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1389", + "sphi2" + ], + "range": { + "start": 119723, + "end": 119771 + } + }, + { + "id": "effect_1661", + "effect_id": "effect@119797:119855", + "bound_var": "b1391", + "source_text": "ctx.insert_t51_lower(b1390.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1390" + ], + "range": { + "start": 119797, + "end": 119855 + } + }, + { + "id": "effect_1662", + "effect_id": "effect@119881:119930", + "bound_var": "r1392", + "source_text": "ctx.insert_t51_approx(b10.clone(), b1391.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b10", + "b1391" + ], + "range": { + "start": 119881, + "end": 119930 + } + }, + { + "id": "effect_1663", + "effect_id": "effect@119944:119983", + "bound_var": null, + "source_text": "ctx.set_to_extract(1398, r1392.clone())", + "semantic_text": "to_extract(1398) = r1392", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1392" + ], + "range": { + "start": 119944, + "end": 119983 + } + }, + { + "id": "effect_1664", + "effect_id": "effect@120009:120053", + "bound_var": "b1393", + "source_text": "ctx.insert_t51_mul(b113.clone(), b7.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b7" + ], + "range": { + "start": 120009, + "end": 120053 + } + }, + { + "id": "effect_1665", + "effect_id": "effect@120079:120126", + "bound_var": "b1394", + "source_text": "ctx.insert_t51_mul(b119.clone(), b1387.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b119", + "b1387" + ], + "range": { + "start": 120079, + "end": 120126 + } + }, + { + "id": "effect_1666", + "effect_id": "effect@120152:120200", + "bound_var": "b1395", + "source_text": "ctx.insert_t51_add(b1393.clone(), b1394.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1393", + "b1394" + ], + "range": { + "start": 120152, + "end": 120200 + } + }, + { + "id": "effect_1667", + "effect_id": "effect@120226:120274", + "bound_var": "b1396", + "source_text": "ctx.insert_t51_mul(b1365.clone(), b1395.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1365", + "b1395" + ], + "range": { + "start": 120226, + "end": 120274 + } + }, + { + "id": "effect_1668", + "effect_id": "effect@120300:120345", + "bound_var": "b1397", + "source_text": "ctx.insert_t51_add(b7.clone(), b1396.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1396", + "b7" + ], + "range": { + "start": 120300, + "end": 120345 + } + }, + { + "id": "effect_1669", + "effect_id": "effect@120371:120419", + "bound_var": "b1398", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1397.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1397", + "sphi2" + ], + "range": { + "start": 120371, + "end": 120419 + } + }, + { + "id": "effect_1670", + "effect_id": "effect@120445:120503", + "bound_var": "b1399", + "source_text": "ctx.insert_t51_lower(b1398.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1398" + ], + "range": { + "start": 120445, + "end": 120503 + } + }, + { + "id": "effect_1671", + "effect_id": "effect@120529:120578", + "bound_var": "r1400", + "source_text": "ctx.insert_t51_approx(b10.clone(), b1399.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b10", + "b1399" + ], + "range": { + "start": 120529, + "end": 120578 + } + }, + { + "id": "effect_1672", + "effect_id": "effect@120592:120631", + "bound_var": null, + "source_text": "ctx.set_to_extract(1406, r1400.clone())", + "semantic_text": "to_extract(1406) = r1400", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1400" + ], + "range": { + "start": 120592, + "end": 120631 + } + }, + { + "id": "effect_1673", + "effect_id": "effect@120657:120704", + "bound_var": "b1401", + "source_text": "ctx.insert_t51_mul(b127.clone(), b1387.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b127", + "b1387" + ], + "range": { + "start": 120657, + "end": 120704 + } + }, + { + "id": "effect_1674", + "effect_id": "effect@120730:120774", + "bound_var": "b1402", + "source_text": "ctx.insert_t51_mul(b119.clone(), b7.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b119", + "b7" + ], + "range": { + "start": 120730, + "end": 120774 + } + }, + { + "id": "effect_1675", + "effect_id": "effect@120800:120848", + "bound_var": "b1403", + "source_text": "ctx.insert_t51_add(b1401.clone(), b1402.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1401", + "b1402" + ], + "range": { + "start": 120800, + "end": 120848 + } + }, + { + "id": "effect_1676", + "effect_id": "effect@120874:120922", + "bound_var": "b1404", + "source_text": "ctx.insert_t51_mul(b1365.clone(), b1403.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1365", + "b1403" + ], + "range": { + "start": 120874, + "end": 120922 + } + }, + { + "id": "effect_1677", + "effect_id": "effect@120948:120996", + "bound_var": "b1405", + "source_text": "ctx.insert_t51_add(b1393.clone(), b1404.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1393", + "b1404" + ], + "range": { + "start": 120948, + "end": 120996 + } + }, + { + "id": "effect_1678", + "effect_id": "effect@121022:121070", + "bound_var": "b1406", + "source_text": "ctx.insert_t51_mul(b1365.clone(), b1405.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1365", + "b1405" + ], + "range": { + "start": 121022, + "end": 121070 + } + }, + { + "id": "effect_1679", + "effect_id": "effect@121096:121141", + "bound_var": "b1407", + "source_text": "ctx.insert_t51_add(b7.clone(), b1406.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1406", + "b7" + ], + "range": { + "start": 121096, + "end": 121141 + } + }, + { + "id": "effect_1680", + "effect_id": "effect@121167:121215", + "bound_var": "b1408", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1407.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1407", + "sphi2" + ], + "range": { + "start": 121167, + "end": 121215 + } + }, + { + "id": "effect_1681", + "effect_id": "effect@121241:121299", + "bound_var": "b1409", + "source_text": "ctx.insert_t51_lower(b1408.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1408" + ], + "range": { + "start": 121241, + "end": 121299 + } + }, + { + "id": "effect_1682", + "effect_id": "effect@121325:121374", + "bound_var": "r1410", + "source_text": "ctx.insert_t51_approx(b10.clone(), b1409.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b10", + "b1409" + ], + "range": { + "start": 121325, + "end": 121374 + } + }, + { + "id": "effect_1683", + "effect_id": "effect@121388:121427", + "bound_var": null, + "source_text": "ctx.set_to_extract(1416, r1410.clone())", + "semantic_text": "to_extract(1416) = r1410", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1410" + ], + "range": { + "start": 121388, + "end": 121427 + } + }, + { + "id": "effect_1684", + "effect_id": "effect@121453:121499", + "bound_var": "b1411", + "source_text": "ctx.insert_t51_mul(b65.clone(), b1365.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1365", + "b65" + ], + "range": { + "start": 121453, + "end": 121499 + } + }, + { + "id": "effect_1685", + "effect_id": "effect@121525:121571", + "bound_var": "b1412", + "source_text": "ctx.insert_t51_add(b87.clone(), b1411.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1411", + "b87" + ], + "range": { + "start": 121525, + "end": 121571 + } + }, + { + "id": "effect_1686", + "effect_id": "effect@121597:121655", + "bound_var": "b1413", + "source_text": "ctx.insert_t51_lower(b1412.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1412" + ], + "range": { + "start": 121597, + "end": 121655 + } + }, + { + "id": "effect_1687", + "effect_id": "effect@121681:121730", + "bound_var": "r1414", + "source_text": "ctx.insert_t51_approx(b12.clone(), b1413.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b12", + "b1413" + ], + "range": { + "start": 121681, + "end": 121730 + } + }, + { + "id": "effect_1688", + "effect_id": "effect@121744:121783", + "bound_var": null, + "source_text": "ctx.set_to_extract(1420, r1414.clone())", + "semantic_text": "to_extract(1420) = r1414", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1414" + ], + "range": { + "start": 121744, + "end": 121783 + } + }, + { + "id": "effect_1689", + "effect_id": "effect@121809:121855", + "bound_var": "b1415", + "source_text": "ctx.insert_t51_mul(b96.clone(), b1365.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1365", + "b96" + ], + "range": { + "start": 121809, + "end": 121855 + } + }, + { + "id": "effect_1690", + "effect_id": "effect@121881:121927", + "bound_var": "b1416", + "source_text": "ctx.insert_t51_sub(b1415.clone(), b98.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1415", + "b98" + ], + "range": { + "start": 121881, + "end": 121927 + } + }, + { + "id": "effect_1691", + "effect_id": "effect@121953:122001", + "bound_var": "b1417", + "source_text": "ctx.insert_t51_mul(b1365.clone(), b1416.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1365", + "b1416" + ], + "range": { + "start": 121953, + "end": 122001 + } + }, + { + "id": "effect_1692", + "effect_id": "effect@122027:122073", + "bound_var": "b1418", + "source_text": "ctx.insert_t51_add(b87.clone(), b1417.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1417", + "b87" + ], + "range": { + "start": 122027, + "end": 122073 + } + }, + { + "id": "effect_1693", + "effect_id": "effect@122099:122157", + "bound_var": "b1419", + "source_text": "ctx.insert_t51_lower(b1418.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1418" + ], + "range": { + "start": 122099, + "end": 122157 + } + }, + { + "id": "effect_1694", + "effect_id": "effect@122183:122232", + "bound_var": "r1420", + "source_text": "ctx.insert_t51_approx(b12.clone(), b1419.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b12", + "b1419" + ], + "range": { + "start": 122183, + "end": 122232 + } + }, + { + "id": "effect_1695", + "effect_id": "effect@122246:122285", + "bound_var": null, + "source_text": "ctx.set_to_extract(1426, r1420.clone())", + "semantic_text": "to_extract(1426) = r1420", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1420" + ], + "range": { + "start": 122246, + "end": 122285 + } + }, + { + "id": "effect_1696", + "effect_id": "effect@122311:122358", + "bound_var": "b1421", + "source_text": "ctx.insert_t51_mul(b104.clone(), b1365.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b104", + "b1365" + ], + "range": { + "start": 122311, + "end": 122358 + } + }, + { + "id": "effect_1697", + "effect_id": "effect@122384:122430", + "bound_var": "b1422", + "source_text": "ctx.insert_t51_add(b96.clone(), b1421.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1421", + "b96" + ], + "range": { + "start": 122384, + "end": 122430 + } + }, + { + "id": "effect_1698", + "effect_id": "effect@122456:122504", + "bound_var": "b1423", + "source_text": "ctx.insert_t51_mul(b1365.clone(), b1422.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1365", + "b1422" + ], + "range": { + "start": 122456, + "end": 122504 + } + }, + { + "id": "effect_1699", + "effect_id": "effect@122530:122576", + "bound_var": "b1424", + "source_text": "ctx.insert_t51_sub(b1423.clone(), b98.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1423", + "b98" + ], + "range": { + "start": 122530, + "end": 122576 + } + }, + { + "id": "effect_1700", + "effect_id": "effect@122602:122650", + "bound_var": "b1425", + "source_text": "ctx.insert_t51_mul(b1365.clone(), b1424.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1365", + "b1424" + ], + "range": { + "start": 122602, + "end": 122650 + } + }, + { + "id": "effect_1701", + "effect_id": "effect@122676:122722", + "bound_var": "b1426", + "source_text": "ctx.insert_t51_add(b87.clone(), b1425.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1425", + "b87" + ], + "range": { + "start": 122676, + "end": 122722 + } + }, + { + "id": "effect_1702", + "effect_id": "effect@122748:122806", + "bound_var": "b1427", + "source_text": "ctx.insert_t51_lower(b1426.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1426" + ], + "range": { + "start": 122748, + "end": 122806 + } + }, + { + "id": "effect_1703", + "effect_id": "effect@122832:122881", + "bound_var": "r1428", + "source_text": "ctx.insert_t51_approx(b12.clone(), b1427.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b12", + "b1427" + ], + "range": { + "start": 122832, + "end": 122881 + } + }, + { + "id": "effect_1704", + "effect_id": "effect@122895:122934", + "bound_var": null, + "source_text": "ctx.set_to_extract(1434, r1428.clone())", + "semantic_text": "to_extract(1434) = r1428", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1428" + ], + "range": { + "start": 122895, + "end": 122934 + } + }, + { + "id": "effect_1705", + "effect_id": "effect@122960:123006", + "bound_var": "b1429", + "source_text": "ctx.insert_t51_mul(b1365.clone(), b11.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b11", + "b1365" + ], + "range": { + "start": 122960, + "end": 123006 + } + }, + { + "id": "effect_1706", + "effect_id": "effect@123032:123078", + "bound_var": "b1430", + "source_text": "ctx.insert_t51_mul(b65.clone(), b1429.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1429", + "b65" + ], + "range": { + "start": 123032, + "end": 123078 + } + }, + { + "id": "effect_1707", + "effect_id": "effect@123104:123150", + "bound_var": "b1431", + "source_text": "ctx.insert_t51_add(b11.clone(), b1430.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b11", + "b1430" + ], + "range": { + "start": 123104, + "end": 123150 + } + }, + { + "id": "effect_1708", + "effect_id": "effect@123176:123234", + "bound_var": "b1432", + "source_text": "ctx.insert_t51_lower(b1431.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1431" + ], + "range": { + "start": 123176, + "end": 123234 + } + }, + { + "id": "effect_1709", + "effect_id": "effect@123260:123309", + "bound_var": "r1433", + "source_text": "ctx.insert_t51_approx(b13.clone(), b1432.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b13", + "b1432" + ], + "range": { + "start": 123260, + "end": 123309 + } + }, + { + "id": "effect_1710", + "effect_id": "effect@123323:123362", + "bound_var": null, + "source_text": "ctx.set_to_extract(1439, r1433.clone())", + "semantic_text": "to_extract(1439) = r1433", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1433" + ], + "range": { + "start": 123323, + "end": 123362 + } + }, + { + "id": "effect_1711", + "effect_id": "effect@123388:123432", + "bound_var": "b1434", + "source_text": "ctx.insert_t51_mul(b65.clone(), b11.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b11", + "b65" + ], + "range": { + "start": 123388, + "end": 123432 + } + }, + { + "id": "effect_1712", + "effect_id": "effect@123458:123504", + "bound_var": "b1435", + "source_text": "ctx.insert_t51_mul(b96.clone(), b1429.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1429", + "b96" + ], + "range": { + "start": 123458, + "end": 123504 + } + }, + { + "id": "effect_1713", + "effect_id": "effect@123530:123578", + "bound_var": "b1436", + "source_text": "ctx.insert_t51_add(b1434.clone(), b1435.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1434", + "b1435" + ], + "range": { + "start": 123530, + "end": 123578 + } + }, + { + "id": "effect_1714", + "effect_id": "effect@123604:123652", + "bound_var": "b1437", + "source_text": "ctx.insert_t51_mul(b1365.clone(), b1436.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1365", + "b1436" + ], + "range": { + "start": 123604, + "end": 123652 + } + }, + { + "id": "effect_1715", + "effect_id": "effect@123678:123724", + "bound_var": "b1438", + "source_text": "ctx.insert_t51_add(b11.clone(), b1437.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b11", + "b1437" + ], + "range": { + "start": 123678, + "end": 123724 + } + }, + { + "id": "effect_1716", + "effect_id": "effect@123750:123808", + "bound_var": "b1439", + "source_text": "ctx.insert_t51_lower(b1438.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1438" + ], + "range": { + "start": 123750, + "end": 123808 + } + }, + { + "id": "effect_1717", + "effect_id": "effect@123834:123883", + "bound_var": "r1440", + "source_text": "ctx.insert_t51_approx(b13.clone(), b1439.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b13", + "b1439" + ], + "range": { + "start": 123834, + "end": 123883 + } + }, + { + "id": "effect_1718", + "effect_id": "effect@123897:123936", + "bound_var": null, + "source_text": "ctx.set_to_extract(1446, r1440.clone())", + "semantic_text": "to_extract(1446) = r1440", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1440" + ], + "range": { + "start": 123897, + "end": 123936 + } + }, + { + "id": "effect_1719", + "effect_id": "effect@123962:124009", + "bound_var": "b1441", + "source_text": "ctx.insert_t51_mul(b104.clone(), b1429.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b104", + "b1429" + ], + "range": { + "start": 123962, + "end": 124009 + } + }, + { + "id": "effect_1720", + "effect_id": "effect@124035:124079", + "bound_var": "b1442", + "source_text": "ctx.insert_t51_mul(b96.clone(), b11.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b11", + "b96" + ], + "range": { + "start": 124035, + "end": 124079 + } + }, + { + "id": "effect_1721", + "effect_id": "effect@124105:124153", + "bound_var": "b1443", + "source_text": "ctx.insert_t51_add(b1441.clone(), b1442.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1441", + "b1442" + ], + "range": { + "start": 124105, + "end": 124153 + } + }, + { + "id": "effect_1722", + "effect_id": "effect@124179:124227", + "bound_var": "b1444", + "source_text": "ctx.insert_t51_mul(b1365.clone(), b1443.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1365", + "b1443" + ], + "range": { + "start": 124179, + "end": 124227 + } + }, + { + "id": "effect_1723", + "effect_id": "effect@124253:124301", + "bound_var": "b1445", + "source_text": "ctx.insert_t51_add(b1434.clone(), b1444.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1434", + "b1444" + ], + "range": { + "start": 124253, + "end": 124301 + } + }, + { + "id": "effect_1724", + "effect_id": "effect@124327:124375", + "bound_var": "b1446", + "source_text": "ctx.insert_t51_mul(b1365.clone(), b1445.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1365", + "b1445" + ], + "range": { + "start": 124327, + "end": 124375 + } + }, + { + "id": "effect_1725", + "effect_id": "effect@124401:124447", + "bound_var": "b1447", + "source_text": "ctx.insert_t51_add(b11.clone(), b1446.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b11", + "b1446" + ], + "range": { + "start": 124401, + "end": 124447 + } + }, + { + "id": "effect_1726", + "effect_id": "effect@124473:124531", + "bound_var": "b1448", + "source_text": "ctx.insert_t51_lower(b1447.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1447" + ], + "range": { + "start": 124473, + "end": 124531 + } + }, + { + "id": "effect_1727", + "effect_id": "effect@124557:124606", + "bound_var": "r1449", + "source_text": "ctx.insert_t51_approx(b13.clone(), b1448.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b13", + "b1448" + ], + "range": { + "start": 124557, + "end": 124606 + } + }, + { + "id": "effect_1728", + "effect_id": "effect@124620:124659", + "bound_var": null, + "source_text": "ctx.set_to_extract(1455, r1449.clone())", + "semantic_text": "to_extract(1455) = r1449", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1449" + ], + "range": { + "start": 124620, + "end": 124659 + } + }, + { + "id": "effect_1729", + "effect_id": "effect@124685:124743", + "bound_var": "b1450", + "source_text": "ctx.insert_t51_lower(b1365.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1365" + ], + "range": { + "start": 124685, + "end": 124743 + } + }, + { + "id": "effect_1730", + "effect_id": "effect@124769:124820", + "bound_var": "r1451", + "source_text": "ctx.insert_t51_approx(b1365.clone(), b1450.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1365", + "b1450" + ], + "range": { + "start": 124769, + "end": 124820 + } + }, + { + "id": "effect_1731", + "effect_id": "effect@124834:124873", + "bound_var": null, + "source_text": "ctx.set_to_extract(1457, r1451.clone())", + "semantic_text": "to_extract(1457) = r1451", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1451" + ], + "range": { + "start": 124834, + "end": 124873 + } + }, + { + "id": "effect_1732", + "effect_id": "effect@124899:124957", + "bound_var": "b1452", + "source_text": "ctx.insert_t51_lower(b1411.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1411" + ], + "range": { + "start": 124899, + "end": 124957 + } + }, + { + "id": "effect_1733", + "effect_id": "effect@124983:125034", + "bound_var": "r1453", + "source_text": "ctx.insert_t51_approx(b1411.clone(), b1452.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1411", + "b1452" + ], + "range": { + "start": 124983, + "end": 125034 + } + }, + { + "id": "effect_1734", + "effect_id": "effect@125048:125087", + "bound_var": null, + "source_text": "ctx.set_to_extract(1459, r1453.clone())", + "semantic_text": "to_extract(1459) = r1453", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1453" + ], + "range": { + "start": 125048, + "end": 125087 + } + }, + { + "id": "effect_1735", + "effect_id": "effect@125113:125157", + "bound_var": "b1454", + "source_text": "ctx.insert_t51_mul(b11.clone(), b17.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b11", + "b17" + ], + "range": { + "start": 125113, + "end": 125157 + } + }, + { + "id": "effect_1736", + "effect_id": "effect@125183:125241", + "bound_var": "b1455", + "source_text": "ctx.insert_t51_lower(b1454.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1454" + ], + "range": { + "start": 125183, + "end": 125241 + } + }, + { + "id": "effect_1737", + "effect_id": "effect@125267:125316", + "bound_var": "r1456", + "source_text": "ctx.insert_t51_approx(b18.clone(), b1455.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1455", + "b18" + ], + "range": { + "start": 125267, + "end": 125316 + } + }, + { + "id": "effect_1738", + "effect_id": "effect@125330:125369", + "bound_var": null, + "source_text": "ctx.set_to_extract(1462, r1456.clone())", + "semantic_text": "to_extract(1462) = r1456", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1456" + ], + "range": { + "start": 125330, + "end": 125369 + } + }, + { + "id": "effect_1739", + "effect_id": "effect@125395:125443", + "bound_var": "b1457", + "source_text": "ctx.insert_t51_mul(b1365.clone(), b1454.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1365", + "b1454" + ], + "range": { + "start": 125395, + "end": 125443 + } + }, + { + "id": "effect_1740", + "effect_id": "effect@125469:125515", + "bound_var": "b1458", + "source_text": "ctx.insert_t51_mul(b65.clone(), b1457.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1457", + "b65" + ], + "range": { + "start": 125469, + "end": 125515 + } + }, + { + "id": "effect_1741", + "effect_id": "effect@125541:125589", + "bound_var": "b1459", + "source_text": "ctx.insert_t51_add(b1458.clone(), b1454.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1454", + "b1458" + ], + "range": { + "start": 125541, + "end": 125589 + } + }, + { + "id": "effect_1742", + "effect_id": "effect@125615:125673", + "bound_var": "b1460", + "source_text": "ctx.insert_t51_lower(b1459.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1459" + ], + "range": { + "start": 125615, + "end": 125673 + } + }, + { + "id": "effect_1743", + "effect_id": "effect@125699:125748", + "bound_var": "r1461", + "source_text": "ctx.insert_t51_approx(b18.clone(), b1460.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1460", + "b18" + ], + "range": { + "start": 125699, + "end": 125748 + } + }, + { + "id": "effect_1744", + "effect_id": "effect@125762:125801", + "bound_var": null, + "source_text": "ctx.set_to_extract(1467, r1461.clone())", + "semantic_text": "to_extract(1467) = r1461", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1461" + ], + "range": { + "start": 125762, + "end": 125801 + } + }, + { + "id": "effect_1745", + "effect_id": "effect@125827:125873", + "bound_var": "b1462", + "source_text": "ctx.insert_t51_mul(b65.clone(), b1454.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1454", + "b65" + ], + "range": { + "start": 125827, + "end": 125873 + } + }, + { + "id": "effect_1746", + "effect_id": "effect@125899:125945", + "bound_var": "b1463", + "source_text": "ctx.insert_t51_mul(b96.clone(), b1457.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1457", + "b96" + ], + "range": { + "start": 125899, + "end": 125945 + } + }, + { + "id": "effect_1747", + "effect_id": "effect@125971:126019", + "bound_var": "b1464", + "source_text": "ctx.insert_t51_add(b1462.clone(), b1463.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1462", + "b1463" + ], + "range": { + "start": 125971, + "end": 126019 + } + }, + { + "id": "effect_1748", + "effect_id": "effect@126045:126093", + "bound_var": "b1465", + "source_text": "ctx.insert_t51_mul(b1365.clone(), b1464.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1365", + "b1464" + ], + "range": { + "start": 126045, + "end": 126093 + } + }, + { + "id": "effect_1749", + "effect_id": "effect@126119:126167", + "bound_var": "b1466", + "source_text": "ctx.insert_t51_add(b1454.clone(), b1465.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1454", + "b1465" + ], + "range": { + "start": 126119, + "end": 126167 + } + }, + { + "id": "effect_1750", + "effect_id": "effect@126193:126251", + "bound_var": "b1467", + "source_text": "ctx.insert_t51_lower(b1466.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1466" + ], + "range": { + "start": 126193, + "end": 126251 + } + }, + { + "id": "effect_1751", + "effect_id": "effect@126277:126326", + "bound_var": "r1468", + "source_text": "ctx.insert_t51_approx(b18.clone(), b1467.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1467", + "b18" + ], + "range": { + "start": 126277, + "end": 126326 + } + }, + { + "id": "effect_1752", + "effect_id": "effect@126340:126379", + "bound_var": null, + "source_text": "ctx.set_to_extract(1474, r1468.clone())", + "semantic_text": "to_extract(1474) = r1468", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1468" + ], + "range": { + "start": 126340, + "end": 126379 + } + }, + { + "id": "effect_1753", + "effect_id": "effect@126405:126452", + "bound_var": "b1469", + "source_text": "ctx.insert_t51_mul(b104.clone(), b1457.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b104", + "b1457" + ], + "range": { + "start": 126405, + "end": 126452 + } + }, + { + "id": "effect_1754", + "effect_id": "effect@126478:126524", + "bound_var": "b1470", + "source_text": "ctx.insert_t51_mul(b96.clone(), b1454.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1454", + "b96" + ], + "range": { + "start": 126478, + "end": 126524 + } + }, + { + "id": "effect_1755", + "effect_id": "effect@126550:126598", + "bound_var": "b1471", + "source_text": "ctx.insert_t51_add(b1469.clone(), b1470.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1469", + "b1470" + ], + "range": { + "start": 126550, + "end": 126598 + } + }, + { + "id": "effect_1756", + "effect_id": "effect@126624:126672", + "bound_var": "b1472", + "source_text": "ctx.insert_t51_mul(b1365.clone(), b1471.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1365", + "b1471" + ], + "range": { + "start": 126624, + "end": 126672 + } + }, + { + "id": "effect_1757", + "effect_id": "effect@126698:126746", + "bound_var": "b1473", + "source_text": "ctx.insert_t51_add(b1462.clone(), b1472.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1462", + "b1472" + ], + "range": { + "start": 126698, + "end": 126746 + } + }, + { + "id": "effect_1758", + "effect_id": "effect@126772:126820", + "bound_var": "b1474", + "source_text": "ctx.insert_t51_mul(b1365.clone(), b1473.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1365", + "b1473" + ], + "range": { + "start": 126772, + "end": 126820 + } + }, + { + "id": "effect_1759", + "effect_id": "effect@126846:126894", + "bound_var": "b1475", + "source_text": "ctx.insert_t51_add(b1454.clone(), b1474.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1454", + "b1474" + ], + "range": { + "start": 126846, + "end": 126894 + } + }, + { + "id": "effect_1760", + "effect_id": "effect@126920:126978", + "bound_var": "b1476", + "source_text": "ctx.insert_t51_lower(b1475.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1475" + ], + "range": { + "start": 126920, + "end": 126978 + } + }, + { + "id": "effect_1761", + "effect_id": "effect@127004:127053", + "bound_var": "r1477", + "source_text": "ctx.insert_t51_approx(b18.clone(), b1476.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1476", + "b18" + ], + "range": { + "start": 127004, + "end": 127053 + } + }, + { + "id": "effect_1762", + "effect_id": "effect@127067:127106", + "bound_var": null, + "source_text": "ctx.set_to_extract(1483, r1477.clone())", + "semantic_text": "to_extract(1483) = r1477", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1477" + ], + "range": { + "start": 127067, + "end": 127106 + } + }, + { + "id": "effect_1763", + "effect_id": "effect@127132:127178", + "bound_var": "b1478", + "source_text": "ctx.insert_t51_mul(b1365.clone(), b35.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1365", + "b35" + ], + "range": { + "start": 127132, + "end": 127178 + } + }, + { + "id": "effect_1764", + "effect_id": "effect@127204:127250", + "bound_var": "b1479", + "source_text": "ctx.insert_t51_mul(b65.clone(), b1478.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1478", + "b65" + ], + "range": { + "start": 127204, + "end": 127250 + } + }, + { + "id": "effect_1765", + "effect_id": "effect@127276:127322", + "bound_var": "b1480", + "source_text": "ctx.insert_t51_add(b1479.clone(), b35.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1479", + "b35" + ], + "range": { + "start": 127276, + "end": 127322 + } + }, + { + "id": "effect_1766", + "effect_id": "effect@127348:127406", + "bound_var": "b1481", + "source_text": "ctx.insert_t51_lower(b1480.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1480" + ], + "range": { + "start": 127348, + "end": 127406 + } + }, + { + "id": "effect_1767", + "effect_id": "effect@127432:127481", + "bound_var": "r1482", + "source_text": "ctx.insert_t51_approx(b40.clone(), b1481.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1481", + "b40" + ], + "range": { + "start": 127432, + "end": 127481 + } + }, + { + "id": "effect_1768", + "effect_id": "effect@127495:127534", + "bound_var": null, + "source_text": "ctx.set_to_extract(1488, r1482.clone())", + "semantic_text": "to_extract(1488) = r1482", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1482" + ], + "range": { + "start": 127495, + "end": 127534 + } + }, + { + "id": "effect_1769", + "effect_id": "effect@127560:127604", + "bound_var": "b1483", + "source_text": "ctx.insert_t51_mul(b65.clone(), b35.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b35", + "b65" + ], + "range": { + "start": 127560, + "end": 127604 + } + }, + { + "id": "effect_1770", + "effect_id": "effect@127630:127676", + "bound_var": "b1484", + "source_text": "ctx.insert_t51_mul(b96.clone(), b1478.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1478", + "b96" + ], + "range": { + "start": 127630, + "end": 127676 + } + }, + { + "id": "effect_1771", + "effect_id": "effect@127702:127750", + "bound_var": "b1485", + "source_text": "ctx.insert_t51_add(b1483.clone(), b1484.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1483", + "b1484" + ], + "range": { + "start": 127702, + "end": 127750 + } + }, + { + "id": "effect_1772", + "effect_id": "effect@127776:127824", + "bound_var": "b1486", + "source_text": "ctx.insert_t51_mul(b1365.clone(), b1485.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1365", + "b1485" + ], + "range": { + "start": 127776, + "end": 127824 + } + }, + { + "id": "effect_1773", + "effect_id": "effect@127850:127896", + "bound_var": "b1487", + "source_text": "ctx.insert_t51_add(b34.clone(), b1486.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1486", + "b34" + ], + "range": { + "start": 127850, + "end": 127896 + } + }, + { + "id": "effect_1774", + "effect_id": "effect@127922:127968", + "bound_var": "b1488", + "source_text": "ctx.insert_t51_add(b31.clone(), b1487.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1487", + "b31" + ], + "range": { + "start": 127922, + "end": 127968 + } + }, + { + "id": "effect_1775", + "effect_id": "effect@127994:128052", + "bound_var": "b1489", + "source_text": "ctx.insert_t51_lower(b1488.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1488" + ], + "range": { + "start": 127994, + "end": 128052 + } + }, + { + "id": "effect_1776", + "effect_id": "effect@128078:128127", + "bound_var": "r1490", + "source_text": "ctx.insert_t51_approx(b40.clone(), b1489.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1489", + "b40" + ], + "range": { + "start": 128078, + "end": 128127 + } + }, + { + "id": "effect_1777", + "effect_id": "effect@128141:128180", + "bound_var": null, + "source_text": "ctx.set_to_extract(1496, r1490.clone())", + "semantic_text": "to_extract(1496) = r1490", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1490" + ], + "range": { + "start": 128141, + "end": 128180 + } + }, + { + "id": "effect_1778", + "effect_id": "effect@128206:128253", + "bound_var": "b1491", + "source_text": "ctx.insert_t51_mul(b104.clone(), b1478.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b104", + "b1478" + ], + "range": { + "start": 128206, + "end": 128253 + } + }, + { + "id": "effect_1779", + "effect_id": "effect@128279:128323", + "bound_var": "b1492", + "source_text": "ctx.insert_t51_mul(b96.clone(), b35.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b35", + "b96" + ], + "range": { + "start": 128279, + "end": 128323 + } + }, + { + "id": "effect_1780", + "effect_id": "effect@128349:128397", + "bound_var": "b1493", + "source_text": "ctx.insert_t51_add(b1491.clone(), b1492.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1491", + "b1492" + ], + "range": { + "start": 128349, + "end": 128397 + } + }, + { + "id": "effect_1781", + "effect_id": "effect@128423:128471", + "bound_var": "b1494", + "source_text": "ctx.insert_t51_mul(b1365.clone(), b1493.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1365", + "b1493" + ], + "range": { + "start": 128423, + "end": 128471 + } + }, + { + "id": "effect_1782", + "effect_id": "effect@128497:128545", + "bound_var": "b1495", + "source_text": "ctx.insert_t51_add(b1483.clone(), b1494.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1483", + "b1494" + ], + "range": { + "start": 128497, + "end": 128545 + } + }, + { + "id": "effect_1783", + "effect_id": "effect@128571:128619", + "bound_var": "b1496", + "source_text": "ctx.insert_t51_mul(b1365.clone(), b1495.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1365", + "b1495" + ], + "range": { + "start": 128571, + "end": 128619 + } + }, + { + "id": "effect_1784", + "effect_id": "effect@128645:128691", + "bound_var": "b1497", + "source_text": "ctx.insert_t51_add(b34.clone(), b1496.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1496", + "b34" + ], + "range": { + "start": 128645, + "end": 128691 + } + }, + { + "id": "effect_1785", + "effect_id": "effect@128717:128763", + "bound_var": "b1498", + "source_text": "ctx.insert_t51_add(b31.clone(), b1497.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1497", + "b31" + ], + "range": { + "start": 128717, + "end": 128763 + } + }, + { + "id": "effect_1786", + "effect_id": "effect@128789:128847", + "bound_var": "b1499", + "source_text": "ctx.insert_t51_lower(b1498.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1498" + ], + "range": { + "start": 128789, + "end": 128847 + } + }, + { + "id": "effect_1787", + "effect_id": "effect@128873:128922", + "bound_var": "r1500", + "source_text": "ctx.insert_t51_approx(b40.clone(), b1499.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1499", + "b40" + ], + "range": { + "start": 128873, + "end": 128922 + } + }, + { + "id": "effect_1788", + "effect_id": "effect@128936:128975", + "bound_var": null, + "source_text": "ctx.set_to_extract(1506, r1500.clone())", + "semantic_text": "to_extract(1506) = r1500", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1500" + ], + "range": { + "start": 128936, + "end": 128975 + } + }, + { + "id": "effect_1789", + "effect_id": "effect@129001:129045", + "bound_var": "b1501", + "source_text": "ctx.insert_t51_mul(b11.clone(), b35.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b11", + "b35" + ], + "range": { + "start": 129001, + "end": 129045 + } + }, + { + "id": "effect_1790", + "effect_id": "effect@129071:129129", + "bound_var": "b1502", + "source_text": "ctx.insert_t51_lower(b1501.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1501" + ], + "range": { + "start": 129071, + "end": 129129 + } + }, + { + "id": "effect_1791", + "effect_id": "effect@129155:129204", + "bound_var": "r1503", + "source_text": "ctx.insert_t51_approx(b42.clone(), b1502.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1502", + "b42" + ], + "range": { + "start": 129155, + "end": 129204 + } + }, + { + "id": "effect_1792", + "effect_id": "effect@129218:129257", + "bound_var": null, + "source_text": "ctx.set_to_extract(1509, r1503.clone())", + "semantic_text": "to_extract(1509) = r1503", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1503" + ], + "range": { + "start": 129218, + "end": 129257 + } + }, + { + "id": "effect_1793", + "effect_id": "effect@129283:129331", + "bound_var": "b1504", + "source_text": "ctx.insert_t51_add(b1234.clone(), b1501.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1234", + "b1501" + ], + "range": { + "start": 129283, + "end": 129331 + } + }, + { + "id": "effect_1794", + "effect_id": "effect@129357:129415", + "bound_var": "b1505", + "source_text": "ctx.insert_t51_lower(b1504.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1504" + ], + "range": { + "start": 129357, + "end": 129415 + } + }, + { + "id": "effect_1795", + "effect_id": "effect@129441:129490", + "bound_var": "r1506", + "source_text": "ctx.insert_t51_approx(b42.clone(), b1505.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1505", + "b42" + ], + "range": { + "start": 129441, + "end": 129490 + } + }, + { + "id": "effect_1796", + "effect_id": "effect@129504:129543", + "bound_var": null, + "source_text": "ctx.set_to_extract(1512, r1506.clone())", + "semantic_text": "to_extract(1512) = r1506", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1506" + ], + "range": { + "start": 129504, + "end": 129543 + } + }, + { + "id": "effect_1797", + "effect_id": "effect@129569:129617", + "bound_var": "b1507", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1501.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1501", + "sphi2" + ], + "range": { + "start": 129569, + "end": 129617 + } + }, + { + "id": "effect_1798", + "effect_id": "effect@129643:129689", + "bound_var": "b1508", + "source_text": "ctx.insert_t51_mul(b65.clone(), b1507.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1507", + "b65" + ], + "range": { + "start": 129643, + "end": 129689 + } + }, + { + "id": "effect_1799", + "effect_id": "effect@129715:129760", + "bound_var": "b1509", + "source_text": "ctx.insert_t51_add(b7.clone(), b1508.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1508", + "b7" + ], + "range": { + "start": 129715, + "end": 129760 + } + }, + { + "id": "effect_1800", + "effect_id": "effect@129786:129834", + "bound_var": "b1510", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1509.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1509", + "sphi2" + ], + "range": { + "start": 129786, + "end": 129834 + } + }, + { + "id": "effect_1801", + "effect_id": "effect@129860:129908", + "bound_var": "b1511", + "source_text": "ctx.insert_t51_add(b1510.clone(), b1501.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1501", + "b1510" + ], + "range": { + "start": 129860, + "end": 129908 + } + }, + { + "id": "effect_1802", + "effect_id": "effect@129934:129992", + "bound_var": "b1512", + "source_text": "ctx.insert_t51_lower(b1511.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1511" + ], + "range": { + "start": 129934, + "end": 129992 + } + }, + { + "id": "effect_1803", + "effect_id": "effect@130018:130067", + "bound_var": "r1513", + "source_text": "ctx.insert_t51_approx(b42.clone(), b1512.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1512", + "b42" + ], + "range": { + "start": 130018, + "end": 130067 + } + }, + { + "id": "effect_1804", + "effect_id": "effect@130081:130120", + "bound_var": null, + "source_text": "ctx.set_to_extract(1519, r1513.clone())", + "semantic_text": "to_extract(1519) = r1513", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1513" + ], + "range": { + "start": 130081, + "end": 130120 + } + }, + { + "id": "effect_1805", + "effect_id": "effect@130146:130192", + "bound_var": "b1514", + "source_text": "ctx.insert_t51_mul(b65.clone(), b1501.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1501", + "b65" + ], + "range": { + "start": 130146, + "end": 130192 + } + }, + { + "id": "effect_1806", + "effect_id": "effect@130218:130265", + "bound_var": "b1515", + "source_text": "ctx.insert_t51_mul(b113.clone(), b1234.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b1234" + ], + "range": { + "start": 130218, + "end": 130265 + } + }, + { + "id": "effect_1807", + "effect_id": "effect@130291:130339", + "bound_var": "b1516", + "source_text": "ctx.insert_t51_add(b1514.clone(), b1515.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1514", + "b1515" + ], + "range": { + "start": 130291, + "end": 130339 + } + }, + { + "id": "effect_1808", + "effect_id": "effect@130365:130413", + "bound_var": "b1517", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1516.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1516", + "sphi2" + ], + "range": { + "start": 130365, + "end": 130413 + } + }, + { + "id": "effect_1809", + "effect_id": "effect@130439:130484", + "bound_var": "b1518", + "source_text": "ctx.insert_t51_add(b7.clone(), b1517.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1517", + "b7" + ], + "range": { + "start": 130439, + "end": 130484 + } + }, + { + "id": "effect_1810", + "effect_id": "effect@130510:130558", + "bound_var": "b1519", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1518.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1518", + "sphi2" + ], + "range": { + "start": 130510, + "end": 130558 + } + }, + { + "id": "effect_1811", + "effect_id": "effect@130584:130632", + "bound_var": "b1520", + "source_text": "ctx.insert_t51_add(b1519.clone(), b1501.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1501", + "b1519" + ], + "range": { + "start": 130584, + "end": 130632 + } + }, + { + "id": "effect_1812", + "effect_id": "effect@130658:130716", + "bound_var": "b1521", + "source_text": "ctx.insert_t51_lower(b1520.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1520" + ], + "range": { + "start": 130658, + "end": 130716 + } + }, + { + "id": "effect_1813", + "effect_id": "effect@130742:130791", + "bound_var": "r1522", + "source_text": "ctx.insert_t51_approx(b42.clone(), b1521.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1521", + "b42" + ], + "range": { + "start": 130742, + "end": 130791 + } + }, + { + "id": "effect_1814", + "effect_id": "effect@130805:130844", + "bound_var": null, + "source_text": "ctx.set_to_extract(1528, r1522.clone())", + "semantic_text": "to_extract(1528) = r1522", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1522" + ], + "range": { + "start": 130805, + "end": 130844 + } + }, + { + "id": "effect_1815", + "effect_id": "effect@130870:130916", + "bound_var": "b1523", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b17.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b17", + "sphi2" + ], + "range": { + "start": 130870, + "end": 130916 + } + }, + { + "id": "effect_1816", + "effect_id": "effect@130942:130988", + "bound_var": "b1524", + "source_text": "ctx.insert_t51_mul(b65.clone(), b1523.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1523", + "b65" + ], + "range": { + "start": 130942, + "end": 130988 + } + }, + { + "id": "effect_1817", + "effect_id": "effect@131014:131062", + "bound_var": "b1525", + "source_text": "ctx.insert_t51_add(sphi1.clone(), b1524.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1524", + "sphi1" + ], + "range": { + "start": 131014, + "end": 131062 + } + }, + { + "id": "effect_1818", + "effect_id": "effect@131088:131136", + "bound_var": "b1526", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1525.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1525", + "sphi2" + ], + "range": { + "start": 131088, + "end": 131136 + } + }, + { + "id": "effect_1819", + "effect_id": "effect@131162:131208", + "bound_var": "b1527", + "source_text": "ctx.insert_t51_add(b17.clone(), b1526.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1526", + "b17" + ], + "range": { + "start": 131162, + "end": 131208 + } + }, + { + "id": "effect_1820", + "effect_id": "effect@131234:131292", + "bound_var": "b1528", + "source_text": "ctx.insert_t51_lower(b1527.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1527" + ], + "range": { + "start": 131234, + "end": 131292 + } + }, + { + "id": "effect_1821", + "effect_id": "effect@131318:131368", + "bound_var": "r1529", + "source_text": "ctx.insert_t51_approx(b280.clone(), b1528.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1528", + "b280" + ], + "range": { + "start": 131318, + "end": 131368 + } + }, + { + "id": "effect_1822", + "effect_id": "effect@131382:131421", + "bound_var": null, + "source_text": "ctx.set_to_extract(1535, r1529.clone())", + "semantic_text": "to_extract(1535) = r1529", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1529" + ], + "range": { + "start": 131382, + "end": 131421 + } + }, + { + "id": "effect_1823", + "effect_id": "effect@131447:131491", + "bound_var": "b1530", + "source_text": "ctx.insert_t51_mul(b65.clone(), b17.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b17", + "b65" + ], + "range": { + "start": 131447, + "end": 131491 + } + }, + { + "id": "effect_1824", + "effect_id": "effect@131517:131563", + "bound_var": "b1531", + "source_text": "ctx.insert_t51_mul(b113.clone(), b262.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b262" + ], + "range": { + "start": 131517, + "end": 131563 + } + }, + { + "id": "effect_1825", + "effect_id": "effect@131589:131637", + "bound_var": "b1532", + "source_text": "ctx.insert_t51_add(b1530.clone(), b1531.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1530", + "b1531" + ], + "range": { + "start": 131589, + "end": 131637 + } + }, + { + "id": "effect_1826", + "effect_id": "effect@131663:131711", + "bound_var": "b1533", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1532.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1532", + "sphi2" + ], + "range": { + "start": 131663, + "end": 131711 + } + }, + { + "id": "effect_1827", + "effect_id": "effect@131737:131785", + "bound_var": "b1534", + "source_text": "ctx.insert_t51_add(sphi1.clone(), b1533.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1533", + "sphi1" + ], + "range": { + "start": 131737, + "end": 131785 + } + }, + { + "id": "effect_1828", + "effect_id": "effect@131811:131859", + "bound_var": "b1535", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1534.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1534", + "sphi2" + ], + "range": { + "start": 131811, + "end": 131859 + } + }, + { + "id": "effect_1829", + "effect_id": "effect@131885:131931", + "bound_var": "b1536", + "source_text": "ctx.insert_t51_add(b17.clone(), b1535.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1535", + "b17" + ], + "range": { + "start": 131885, + "end": 131931 + } + }, + { + "id": "effect_1830", + "effect_id": "effect@131957:132015", + "bound_var": "b1537", + "source_text": "ctx.insert_t51_lower(b1536.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1536" + ], + "range": { + "start": 131957, + "end": 132015 + } + }, + { + "id": "effect_1831", + "effect_id": "effect@132041:132091", + "bound_var": "r1538", + "source_text": "ctx.insert_t51_approx(b280.clone(), b1537.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1537", + "b280" + ], + "range": { + "start": 132041, + "end": 132091 + } + }, + { + "id": "effect_1832", + "effect_id": "effect@132105:132144", + "bound_var": null, + "source_text": "ctx.set_to_extract(1544, r1538.clone())", + "semantic_text": "to_extract(1544) = r1538", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1538" + ], + "range": { + "start": 132105, + "end": 132144 + } + }, + { + "id": "effect_1833", + "effect_id": "effect@132170:132217", + "bound_var": "b1539", + "source_text": "ctx.insert_t51_add(b1343.clone(), b307.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1343", + "b307" + ], + "range": { + "start": 132170, + "end": 132217 + } + }, + { + "id": "effect_1834", + "effect_id": "effect@132243:132294", + "bound_var": "b1540", + "source_text": "ctx.insert_t51_add(slambda1.clone(), b1539.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1539", + "slambda1" + ], + "range": { + "start": 132243, + "end": 132294 + } + }, + { + "id": "effect_1835", + "effect_id": "effect@132320:132371", + "bound_var": "b1541", + "source_text": "ctx.insert_t51_sub(b1540.clone(), slambda2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1540", + "slambda2" + ], + "range": { + "start": 132320, + "end": 132371 + } + }, + { + "id": "effect_1836", + "effect_id": "effect@132397:132455", + "bound_var": "b1542", + "source_text": "ctx.insert_t51_lower(b1541.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1541" + ], + "range": { + "start": 132397, + "end": 132455 + } + }, + { + "id": "effect_1837", + "effect_id": "effect@132481:132531", + "bound_var": "r1543", + "source_text": "ctx.insert_t51_approx(b316.clone(), b1542.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1542", + "b316" + ], + "range": { + "start": 132481, + "end": 132531 + } + }, + { + "id": "effect_1838", + "effect_id": "effect@132545:132584", + "bound_var": null, + "source_text": "ctx.set_to_extract(1549, r1543.clone())", + "semantic_text": "to_extract(1549) = r1543", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1543" + ], + "range": { + "start": 132545, + "end": 132584 + } + }, + { + "id": "effect_1839", + "effect_id": "effect@132610:132642", + "bound_var": "b1544", + "source_text": "ctx.insert_t51_sin(b313.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b313" + ], + "range": { + "start": 132610, + "end": 132642 + } + }, + { + "id": "effect_1840", + "effect_id": "effect@132668:132726", + "bound_var": "b1545", + "source_text": "ctx.insert_t51_lower(b1544.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1544" + ], + "range": { + "start": 132668, + "end": 132726 + } + }, + { + "id": "effect_1841", + "effect_id": "effect@132752:132802", + "bound_var": "r1546", + "source_text": "ctx.insert_t51_approx(b324.clone(), b1545.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1545", + "b324" + ], + "range": { + "start": 132752, + "end": 132802 + } + }, + { + "id": "effect_1842", + "effect_id": "effect@132816:132855", + "bound_var": null, + "source_text": "ctx.set_to_extract(1552, r1546.clone())", + "semantic_text": "to_extract(1552) = r1546", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1546" + ], + "range": { + "start": 132816, + "end": 132855 + } + }, + { + "id": "effect_1843", + "effect_id": "effect@132881:132913", + "bound_var": "b1547", + "source_text": "ctx.insert_t51_cos(b313.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b313" + ], + "range": { + "start": 132881, + "end": 132913 + } + }, + { + "id": "effect_1844", + "effect_id": "effect@132939:132987", + "bound_var": "b1548", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1547.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1547", + "sphi2" + ], + "range": { + "start": 132939, + "end": 132987 + } + }, + { + "id": "effect_1845", + "effect_id": "effect@133013:133059", + "bound_var": "b1549", + "source_text": "ctx.insert_t51_mul(b49.clone(), b1548.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1548", + "b49" + ], + "range": { + "start": 133013, + "end": 133059 + } + }, + { + "id": "effect_1846", + "effect_id": "effect@133085:133133", + "bound_var": "b1550", + "source_text": "ctx.insert_t51_add(b1544.clone(), b1549.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1544", + "b1549" + ], + "range": { + "start": 133085, + "end": 133133 + } + }, + { + "id": "effect_1847", + "effect_id": "effect@133159:133217", + "bound_var": "b1551", + "source_text": "ctx.insert_t51_lower(b1550.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1550" + ], + "range": { + "start": 133159, + "end": 133217 + } + }, + { + "id": "effect_1848", + "effect_id": "effect@133243:133293", + "bound_var": "r1552", + "source_text": "ctx.insert_t51_approx(b324.clone(), b1551.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1551", + "b324" + ], + "range": { + "start": 133243, + "end": 133293 + } + }, + { + "id": "effect_1849", + "effect_id": "effect@133307:133346", + "bound_var": null, + "source_text": "ctx.set_to_extract(1558, r1552.clone())", + "semantic_text": "to_extract(1558) = r1552", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1552" + ], + "range": { + "start": 133307, + "end": 133346 + } + }, + { + "id": "effect_1850", + "effect_id": "effect@133372:133418", + "bound_var": "b1553", + "source_text": "ctx.insert_t51_mul(b49.clone(), b1547.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1547", + "b49" + ], + "range": { + "start": 133372, + "end": 133418 + } + }, + { + "id": "effect_1851", + "effect_id": "effect@133444:133492", + "bound_var": "b1554", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1544.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1544", + "sphi2" + ], + "range": { + "start": 133444, + "end": 133492 + } + }, + { + "id": "effect_1852", + "effect_id": "effect@133518:133564", + "bound_var": "b1555", + "source_text": "ctx.insert_t51_mul(b65.clone(), b1554.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1554", + "b65" + ], + "range": { + "start": 133518, + "end": 133564 + } + }, + { + "id": "effect_1853", + "effect_id": "effect@133590:133638", + "bound_var": "b1556", + "source_text": "ctx.insert_t51_add(b1553.clone(), b1555.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1553", + "b1555" + ], + "range": { + "start": 133590, + "end": 133638 + } + }, + { + "id": "effect_1854", + "effect_id": "effect@133664:133712", + "bound_var": "b1557", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1556.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1556", + "sphi2" + ], + "range": { + "start": 133664, + "end": 133712 + } + }, + { + "id": "effect_1855", + "effect_id": "effect@133738:133786", + "bound_var": "b1558", + "source_text": "ctx.insert_t51_add(b1544.clone(), b1557.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1544", + "b1557" + ], + "range": { + "start": 133738, + "end": 133786 + } + }, + { + "id": "effect_1856", + "effect_id": "effect@133812:133870", + "bound_var": "b1559", + "source_text": "ctx.insert_t51_lower(b1558.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1558" + ], + "range": { + "start": 133812, + "end": 133870 + } + }, + { + "id": "effect_1857", + "effect_id": "effect@133896:133946", + "bound_var": "r1560", + "source_text": "ctx.insert_t51_approx(b324.clone(), b1559.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1559", + "b324" + ], + "range": { + "start": 133896, + "end": 133946 + } + }, + { + "id": "effect_1858", + "effect_id": "effect@133960:133999", + "bound_var": null, + "source_text": "ctx.set_to_extract(1566, r1560.clone())", + "semantic_text": "to_extract(1566) = r1560", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1560" + ], + "range": { + "start": 133960, + "end": 133999 + } + }, + { + "id": "effect_1859", + "effect_id": "effect@134025:134071", + "bound_var": "b1561", + "source_text": "ctx.insert_t51_mul(b65.clone(), b1544.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1544", + "b65" + ], + "range": { + "start": 134025, + "end": 134071 + } + }, + { + "id": "effect_1860", + "effect_id": "effect@134097:134143", + "bound_var": "b1562", + "source_text": "ctx.insert_t51_mul(b74.clone(), b1548.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1548", + "b74" + ], + "range": { + "start": 134097, + "end": 134143 + } + }, + { + "id": "effect_1861", + "effect_id": "effect@134169:134217", + "bound_var": "b1563", + "source_text": "ctx.insert_t51_add(b1561.clone(), b1562.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1561", + "b1562" + ], + "range": { + "start": 134169, + "end": 134217 + } + }, + { + "id": "effect_1862", + "effect_id": "effect@134243:134291", + "bound_var": "b1564", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1563.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1563", + "sphi2" + ], + "range": { + "start": 134243, + "end": 134291 + } + }, + { + "id": "effect_1863", + "effect_id": "effect@134317:134365", + "bound_var": "b1565", + "source_text": "ctx.insert_t51_add(b1553.clone(), b1564.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1553", + "b1564" + ], + "range": { + "start": 134317, + "end": 134365 + } + }, + { + "id": "effect_1864", + "effect_id": "effect@134391:134439", + "bound_var": "b1566", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1565.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1565", + "sphi2" + ], + "range": { + "start": 134391, + "end": 134439 + } + }, + { + "id": "effect_1865", + "effect_id": "effect@134465:134513", + "bound_var": "b1567", + "source_text": "ctx.insert_t51_add(b1544.clone(), b1566.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1544", + "b1566" + ], + "range": { + "start": 134465, + "end": 134513 + } + }, + { + "id": "effect_1866", + "effect_id": "effect@134539:134597", + "bound_var": "b1568", + "source_text": "ctx.insert_t51_lower(b1567.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1567" + ], + "range": { + "start": 134539, + "end": 134597 + } + }, + { + "id": "effect_1867", + "effect_id": "effect@134623:134673", + "bound_var": "r1569", + "source_text": "ctx.insert_t51_approx(b324.clone(), b1568.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1568", + "b324" + ], + "range": { + "start": 134623, + "end": 134673 + } + }, + { + "id": "effect_1868", + "effect_id": "effect@134687:134726", + "bound_var": null, + "source_text": "ctx.set_to_extract(1575, r1569.clone())", + "semantic_text": "to_extract(1575) = r1569", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1569" + ], + "range": { + "start": 134687, + "end": 134726 + } + }, + { + "id": "effect_1869", + "effect_id": "effect@134752:134800", + "bound_var": "b1570", + "source_text": "ctx.insert_t51_add(b1544.clone(), b1548.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1544", + "b1548" + ], + "range": { + "start": 134752, + "end": 134800 + } + }, + { + "id": "effect_1870", + "effect_id": "effect@134826:134884", + "bound_var": "b1571", + "source_text": "ctx.insert_t51_lower(b1570.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1570" + ], + "range": { + "start": 134826, + "end": 134884 + } + }, + { + "id": "effect_1871", + "effect_id": "effect@134910:134960", + "bound_var": "r1572", + "source_text": "ctx.insert_t51_approx(b358.clone(), b1571.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1571", + "b358" + ], + "range": { + "start": 134910, + "end": 134960 + } + }, + { + "id": "effect_1872", + "effect_id": "effect@134974:135013", + "bound_var": null, + "source_text": "ctx.set_to_extract(1578, r1572.clone())", + "semantic_text": "to_extract(1578) = r1572", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1572" + ], + "range": { + "start": 134974, + "end": 135013 + } + }, + { + "id": "effect_1873", + "effect_id": "effect@135039:135087", + "bound_var": "b1573", + "source_text": "ctx.insert_t51_add(b1547.clone(), b1555.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1547", + "b1555" + ], + "range": { + "start": 135039, + "end": 135087 + } + }, + { + "id": "effect_1874", + "effect_id": "effect@135113:135161", + "bound_var": "b1574", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1573.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1573", + "sphi2" + ], + "range": { + "start": 135113, + "end": 135161 + } + }, + { + "id": "effect_1875", + "effect_id": "effect@135187:135235", + "bound_var": "b1575", + "source_text": "ctx.insert_t51_add(b1544.clone(), b1574.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1544", + "b1574" + ], + "range": { + "start": 135187, + "end": 135235 + } + }, + { + "id": "effect_1876", + "effect_id": "effect@135261:135319", + "bound_var": "b1576", + "source_text": "ctx.insert_t51_lower(b1575.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1575" + ], + "range": { + "start": 135261, + "end": 135319 + } + }, + { + "id": "effect_1877", + "effect_id": "effect@135345:135395", + "bound_var": "r1577", + "source_text": "ctx.insert_t51_approx(b358.clone(), b1576.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1576", + "b358" + ], + "range": { + "start": 135345, + "end": 135395 + } + }, + { + "id": "effect_1878", + "effect_id": "effect@135409:135448", + "bound_var": null, + "source_text": "ctx.set_to_extract(1583, r1577.clone())", + "semantic_text": "to_extract(1583) = r1577", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1577" + ], + "range": { + "start": 135409, + "end": 135448 + } + }, + { + "id": "effect_1879", + "effect_id": "effect@135474:135521", + "bound_var": "b1578", + "source_text": "ctx.insert_t51_mul(b113.clone(), b1548.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b1548" + ], + "range": { + "start": 135474, + "end": 135521 + } + }, + { + "id": "effect_1880", + "effect_id": "effect@135547:135595", + "bound_var": "b1579", + "source_text": "ctx.insert_t51_add(b1561.clone(), b1578.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1561", + "b1578" + ], + "range": { + "start": 135547, + "end": 135595 + } + }, + { + "id": "effect_1881", + "effect_id": "effect@135621:135669", + "bound_var": "b1580", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1579.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1579", + "sphi2" + ], + "range": { + "start": 135621, + "end": 135669 + } + }, + { + "id": "effect_1882", + "effect_id": "effect@135695:135743", + "bound_var": "b1581", + "source_text": "ctx.insert_t51_add(b1547.clone(), b1580.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1547", + "b1580" + ], + "range": { + "start": 135695, + "end": 135743 + } + }, + { + "id": "effect_1883", + "effect_id": "effect@135769:135817", + "bound_var": "b1582", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1581.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1581", + "sphi2" + ], + "range": { + "start": 135769, + "end": 135817 + } + }, + { + "id": "effect_1884", + "effect_id": "effect@135843:135891", + "bound_var": "b1583", + "source_text": "ctx.insert_t51_add(b1544.clone(), b1582.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1544", + "b1582" + ], + "range": { + "start": 135843, + "end": 135891 + } + }, + { + "id": "effect_1885", + "effect_id": "effect@135917:135975", + "bound_var": "b1584", + "source_text": "ctx.insert_t51_lower(b1583.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1583" + ], + "range": { + "start": 135917, + "end": 135975 + } + }, + { + "id": "effect_1886", + "effect_id": "effect@136001:136051", + "bound_var": "r1585", + "source_text": "ctx.insert_t51_approx(b358.clone(), b1584.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1584", + "b358" + ], + "range": { + "start": 136001, + "end": 136051 + } + }, + { + "id": "effect_1887", + "effect_id": "effect@136065:136104", + "bound_var": null, + "source_text": "ctx.set_to_extract(1591, r1585.clone())", + "semantic_text": "to_extract(1591) = r1585", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1585" + ], + "range": { + "start": 136065, + "end": 136104 + } + }, + { + "id": "effect_1888", + "effect_id": "effect@136130:136176", + "bound_var": "b1586", + "source_text": "ctx.insert_t51_mul(b90.clone(), b1544.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1544", + "b90" + ], + "range": { + "start": 136130, + "end": 136176 + } + }, + { + "id": "effect_1889", + "effect_id": "effect@136202:136260", + "bound_var": "b1587", + "source_text": "ctx.insert_t51_lower(b1586.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1586" + ], + "range": { + "start": 136202, + "end": 136260 + } + }, + { + "id": "effect_1890", + "effect_id": "effect@136286:136336", + "bound_var": "r1588", + "source_text": "ctx.insert_t51_approx(b383.clone(), b1587.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1587", + "b383" + ], + "range": { + "start": 136286, + "end": 136336 + } + }, + { + "id": "effect_1891", + "effect_id": "effect@136350:136389", + "bound_var": null, + "source_text": "ctx.set_to_extract(1594, r1588.clone())", + "semantic_text": "to_extract(1594) = r1588", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1588" + ], + "range": { + "start": 136350, + "end": 136389 + } + }, + { + "id": "effect_1892", + "effect_id": "effect@136415:136463", + "bound_var": "b1589", + "source_text": "ctx.insert_t51_add(b1547.clone(), b1553.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1547", + "b1553" + ], + "range": { + "start": 136415, + "end": 136463 + } + }, + { + "id": "effect_1893", + "effect_id": "effect@136489:136537", + "bound_var": "b1590", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1589.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1589", + "sphi2" + ], + "range": { + "start": 136489, + "end": 136537 + } + }, + { + "id": "effect_1894", + "effect_id": "effect@136563:136611", + "bound_var": "b1591", + "source_text": "ctx.insert_t51_add(b1586.clone(), b1590.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1586", + "b1590" + ], + "range": { + "start": 136563, + "end": 136611 + } + }, + { + "id": "effect_1895", + "effect_id": "effect@136637:136695", + "bound_var": "b1592", + "source_text": "ctx.insert_t51_lower(b1591.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1591" + ], + "range": { + "start": 136637, + "end": 136695 + } + }, + { + "id": "effect_1896", + "effect_id": "effect@136721:136771", + "bound_var": "r1593", + "source_text": "ctx.insert_t51_approx(b383.clone(), b1592.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1592", + "b383" + ], + "range": { + "start": 136721, + "end": 136771 + } + }, + { + "id": "effect_1897", + "effect_id": "effect@136785:136824", + "bound_var": null, + "source_text": "ctx.set_to_extract(1599, r1593.clone())", + "semantic_text": "to_extract(1599) = r1593", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1593" + ], + "range": { + "start": 136785, + "end": 136824 + } + }, + { + "id": "effect_1898", + "effect_id": "effect@136850:136896", + "bound_var": "b1594", + "source_text": "ctx.insert_t51_mul(b49.clone(), b1554.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1554", + "b49" + ], + "range": { + "start": 136850, + "end": 136896 + } + }, + { + "id": "effect_1899", + "effect_id": "effect@136922:136970", + "bound_var": "b1595", + "source_text": "ctx.insert_t51_add(b1553.clone(), b1594.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1553", + "b1594" + ], + "range": { + "start": 136922, + "end": 136970 + } + }, + { + "id": "effect_1900", + "effect_id": "effect@136996:137044", + "bound_var": "b1596", + "source_text": "ctx.insert_t51_add(b1547.clone(), b1595.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1547", + "b1595" + ], + "range": { + "start": 136996, + "end": 137044 + } + }, + { + "id": "effect_1901", + "effect_id": "effect@137070:137118", + "bound_var": "b1597", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1596.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1596", + "sphi2" + ], + "range": { + "start": 137070, + "end": 137118 + } + }, + { + "id": "effect_1902", + "effect_id": "effect@137144:137192", + "bound_var": "b1598", + "source_text": "ctx.insert_t51_add(b1586.clone(), b1597.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1586", + "b1597" + ], + "range": { + "start": 137144, + "end": 137192 + } + }, + { + "id": "effect_1903", + "effect_id": "effect@137218:137276", + "bound_var": "b1599", + "source_text": "ctx.insert_t51_lower(b1598.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1598" + ], + "range": { + "start": 137218, + "end": 137276 + } + }, + { + "id": "effect_1904", + "effect_id": "effect@137302:137352", + "bound_var": "r1600", + "source_text": "ctx.insert_t51_approx(b383.clone(), b1599.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1599", + "b383" + ], + "range": { + "start": 137302, + "end": 137352 + } + }, + { + "id": "effect_1905", + "effect_id": "effect@137366:137405", + "bound_var": null, + "source_text": "ctx.set_to_extract(1606, r1600.clone())", + "semantic_text": "to_extract(1606) = r1600", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1600" + ], + "range": { + "start": 137366, + "end": 137405 + } + }, + { + "id": "effect_1906", + "effect_id": "effect@137431:137477", + "bound_var": "b1601", + "source_text": "ctx.insert_t51_mul(b49.clone(), b1544.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1544", + "b49" + ], + "range": { + "start": 137431, + "end": 137477 + } + }, + { + "id": "effect_1907", + "effect_id": "effect@137503:137550", + "bound_var": "b1602", + "source_text": "ctx.insert_t51_mul(b113.clone(), b1547.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "b1547" + ], + "range": { + "start": 137503, + "end": 137550 + } + }, + { + "id": "effect_1908", + "effect_id": "effect@137576:137622", + "bound_var": "b1603", + "source_text": "ctx.insert_t51_mul(b74.clone(), b1547.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1547", + "b74" + ], + "range": { + "start": 137576, + "end": 137622 + } + }, + { + "id": "effect_1909", + "effect_id": "effect@137648:137696", + "bound_var": "b1604", + "source_text": "ctx.insert_t51_add(b1602.clone(), b1603.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1602", + "b1603" + ], + "range": { + "start": 137648, + "end": 137696 + } + }, + { + "id": "effect_1910", + "effect_id": "effect@137722:137770", + "bound_var": "b1605", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1604.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1604", + "sphi2" + ], + "range": { + "start": 137722, + "end": 137770 + } + }, + { + "id": "effect_1911", + "effect_id": "effect@137796:137844", + "bound_var": "b1606", + "source_text": "ctx.insert_t51_add(b1601.clone(), b1605.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1601", + "b1605" + ], + "range": { + "start": 137796, + "end": 137844 + } + }, + { + "id": "effect_1912", + "effect_id": "effect@137870:137918", + "bound_var": "b1607", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1606.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1606", + "sphi2" + ], + "range": { + "start": 137870, + "end": 137918 + } + }, + { + "id": "effect_1913", + "effect_id": "effect@137944:137992", + "bound_var": "b1608", + "source_text": "ctx.insert_t51_add(b1553.clone(), b1607.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1553", + "b1607" + ], + "range": { + "start": 137944, + "end": 137992 + } + }, + { + "id": "effect_1914", + "effect_id": "effect@138018:138066", + "bound_var": "b1609", + "source_text": "ctx.insert_t51_add(b1547.clone(), b1608.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1547", + "b1608" + ], + "range": { + "start": 138018, + "end": 138066 + } + }, + { + "id": "effect_1915", + "effect_id": "effect@138092:138140", + "bound_var": "b1610", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1609.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1609", + "sphi2" + ], + "range": { + "start": 138092, + "end": 138140 + } + }, + { + "id": "effect_1916", + "effect_id": "effect@138166:138214", + "bound_var": "b1611", + "source_text": "ctx.insert_t51_add(b1586.clone(), b1610.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1586", + "b1610" + ], + "range": { + "start": 138166, + "end": 138214 + } + }, + { + "id": "effect_1917", + "effect_id": "effect@138240:138298", + "bound_var": "b1612", + "source_text": "ctx.insert_t51_lower(b1611.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1611" + ], + "range": { + "start": 138240, + "end": 138298 + } + }, + { + "id": "effect_1918", + "effect_id": "effect@138324:138374", + "bound_var": "r1613", + "source_text": "ctx.insert_t51_approx(b383.clone(), b1612.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1612", + "b383" + ], + "range": { + "start": 138324, + "end": 138374 + } + }, + { + "id": "effect_1919", + "effect_id": "effect@138388:138427", + "bound_var": null, + "source_text": "ctx.set_to_extract(1619, r1613.clone())", + "semantic_text": "to_extract(1619) = r1613", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1613" + ], + "range": { + "start": 138388, + "end": 138427 + } + }, + { + "id": "effect_1920", + "effect_id": "effect@138453:138499", + "bound_var": "b1614", + "source_text": "ctx.insert_t51_mul(b98.clone(), b1590.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1590", + "b98" + ], + "range": { + "start": 138453, + "end": 138499 + } + }, + { + "id": "effect_1921", + "effect_id": "effect@138525:138573", + "bound_var": "b1615", + "source_text": "ctx.insert_t51_add(b1544.clone(), b1614.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1544", + "b1614" + ], + "range": { + "start": 138525, + "end": 138573 + } + }, + { + "id": "effect_1922", + "effect_id": "effect@138599:138657", + "bound_var": "b1616", + "source_text": "ctx.insert_t51_lower(b1615.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1615" + ], + "range": { + "start": 138599, + "end": 138657 + } + }, + { + "id": "effect_1923", + "effect_id": "effect@138683:138733", + "bound_var": "r1617", + "source_text": "ctx.insert_t51_approx(b416.clone(), b1616.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1616", + "b416" + ], + "range": { + "start": 138683, + "end": 138733 + } + }, + { + "id": "effect_1924", + "effect_id": "effect@138747:138786", + "bound_var": null, + "source_text": "ctx.set_to_extract(1623, r1617.clone())", + "semantic_text": "to_extract(1623) = r1617", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1617" + ], + "range": { + "start": 138747, + "end": 138786 + } + }, + { + "id": "effect_1925", + "effect_id": "effect@138812:138858", + "bound_var": "b1618", + "source_text": "ctx.insert_t51_mul(b98.clone(), b1589.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1589", + "b98" + ], + "range": { + "start": 138812, + "end": 138858 + } + }, + { + "id": "effect_1926", + "effect_id": "effect@138884:138932", + "bound_var": "b1619", + "source_text": "ctx.insert_t51_add(b1555.clone(), b1618.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1555", + "b1618" + ], + "range": { + "start": 138884, + "end": 138932 + } + }, + { + "id": "effect_1927", + "effect_id": "effect@138958:139006", + "bound_var": "b1620", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1619.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1619", + "sphi2" + ], + "range": { + "start": 138958, + "end": 139006 + } + }, + { + "id": "effect_1928", + "effect_id": "effect@139032:139080", + "bound_var": "b1621", + "source_text": "ctx.insert_t51_add(b1544.clone(), b1620.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1544", + "b1620" + ], + "range": { + "start": 139032, + "end": 139080 + } + }, + { + "id": "effect_1929", + "effect_id": "effect@139106:139164", + "bound_var": "b1622", + "source_text": "ctx.insert_t51_lower(b1621.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1621" + ], + "range": { + "start": 139106, + "end": 139164 + } + }, + { + "id": "effect_1930", + "effect_id": "effect@139190:139240", + "bound_var": "r1623", + "source_text": "ctx.insert_t51_approx(b416.clone(), b1622.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1622", + "b416" + ], + "range": { + "start": 139190, + "end": 139240 + } + }, + { + "id": "effect_1931", + "effect_id": "effect@139254:139293", + "bound_var": null, + "source_text": "ctx.set_to_extract(1629, r1623.clone())", + "semantic_text": "to_extract(1629) = r1623", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1623" + ], + "range": { + "start": 139254, + "end": 139293 + } + }, + { + "id": "effect_1932", + "effect_id": "effect@139319:139365", + "bound_var": "b1624", + "source_text": "ctx.insert_t51_mul(b98.clone(), b1605.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1605", + "b98" + ], + "range": { + "start": 139319, + "end": 139365 + } + }, + { + "id": "effect_1933", + "effect_id": "effect@139391:139439", + "bound_var": "b1625", + "source_text": "ctx.insert_t51_add(b1561.clone(), b1624.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1561", + "b1624" + ], + "range": { + "start": 139391, + "end": 139439 + } + }, + { + "id": "effect_1934", + "effect_id": "effect@139465:139513", + "bound_var": "b1626", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1625.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1625", + "sphi2" + ], + "range": { + "start": 139465, + "end": 139513 + } + }, + { + "id": "effect_1935", + "effect_id": "effect@139539:139587", + "bound_var": "b1627", + "source_text": "ctx.insert_t51_add(b1618.clone(), b1626.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1618", + "b1626" + ], + "range": { + "start": 139539, + "end": 139587 + } + }, + { + "id": "effect_1936", + "effect_id": "effect@139613:139661", + "bound_var": "b1628", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1627.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1627", + "sphi2" + ], + "range": { + "start": 139613, + "end": 139661 + } + }, + { + "id": "effect_1937", + "effect_id": "effect@139687:139735", + "bound_var": "b1629", + "source_text": "ctx.insert_t51_add(b1544.clone(), b1628.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1544", + "b1628" + ], + "range": { + "start": 139687, + "end": 139735 + } + }, + { + "id": "effect_1938", + "effect_id": "effect@139761:139819", + "bound_var": "b1630", + "source_text": "ctx.insert_t51_lower(b1629.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1629" + ], + "range": { + "start": 139761, + "end": 139819 + } + }, + { + "id": "effect_1939", + "effect_id": "effect@139845:139895", + "bound_var": "r1631", + "source_text": "ctx.insert_t51_approx(b416.clone(), b1630.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1630", + "b416" + ], + "range": { + "start": 139845, + "end": 139895 + } + }, + { + "id": "effect_1940", + "effect_id": "effect@139909:139948", + "bound_var": null, + "source_text": "ctx.set_to_extract(1637, r1631.clone())", + "semantic_text": "to_extract(1637) = r1631", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1631" + ], + "range": { + "start": 139909, + "end": 139948 + } + }, + { + "id": "effect_1941", + "effect_id": "effect@139974:140022", + "bound_var": "b1632", + "source_text": "ctx.insert_t51_add(sphi1.clone(), b1618.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1618", + "sphi1" + ], + "range": { + "start": 139974, + "end": 140022 + } + }, + { + "id": "effect_1942", + "effect_id": "effect@140048:140096", + "bound_var": "b1633", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1632.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1632", + "sphi2" + ], + "range": { + "start": 140048, + "end": 140096 + } + }, + { + "id": "effect_1943", + "effect_id": "effect@140122:140170", + "bound_var": "b1634", + "source_text": "ctx.insert_t51_add(b1544.clone(), b1633.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1544", + "b1633" + ], + "range": { + "start": 140122, + "end": 140170 + } + }, + { + "id": "effect_1944", + "effect_id": "effect@140196:140254", + "bound_var": "b1635", + "source_text": "ctx.insert_t51_lower(b1634.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1634" + ], + "range": { + "start": 140196, + "end": 140254 + } + }, + { + "id": "effect_1945", + "effect_id": "effect@140280:140330", + "bound_var": "r1636", + "source_text": "ctx.insert_t51_approx(b440.clone(), b1635.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1635", + "b440" + ], + "range": { + "start": 140280, + "end": 140330 + } + }, + { + "id": "effect_1946", + "effect_id": "effect@140344:140383", + "bound_var": null, + "source_text": "ctx.set_to_extract(1642, r1636.clone())", + "semantic_text": "to_extract(1642) = r1636", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1636" + ], + "range": { + "start": 140344, + "end": 140383 + } + }, + { + "id": "effect_1947", + "effect_id": "effect@140409:140457", + "bound_var": "b1637", + "source_text": "ctx.insert_t51_add(sphi1.clone(), b1619.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1619", + "sphi1" + ], + "range": { + "start": 140409, + "end": 140457 + } + }, + { + "id": "effect_1948", + "effect_id": "effect@140483:140531", + "bound_var": "b1638", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1637.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1637", + "sphi2" + ], + "range": { + "start": 140483, + "end": 140531 + } + }, + { + "id": "effect_1949", + "effect_id": "effect@140557:140605", + "bound_var": "b1639", + "source_text": "ctx.insert_t51_add(b1544.clone(), b1638.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1544", + "b1638" + ], + "range": { + "start": 140557, + "end": 140605 + } + }, + { + "id": "effect_1950", + "effect_id": "effect@140631:140689", + "bound_var": "b1640", + "source_text": "ctx.insert_t51_lower(b1639.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1639" + ], + "range": { + "start": 140631, + "end": 140689 + } + }, + { + "id": "effect_1951", + "effect_id": "effect@140715:140765", + "bound_var": "r1641", + "source_text": "ctx.insert_t51_approx(b440.clone(), b1640.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1640", + "b440" + ], + "range": { + "start": 140715, + "end": 140765 + } + }, + { + "id": "effect_1952", + "effect_id": "effect@140779:140818", + "bound_var": null, + "source_text": "ctx.set_to_extract(1647, r1641.clone())", + "semantic_text": "to_extract(1647) = r1641", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1641" + ], + "range": { + "start": 140779, + "end": 140818 + } + }, + { + "id": "effect_1953", + "effect_id": "effect@140844:140891", + "bound_var": "b1642", + "source_text": "ctx.insert_t51_mul(b113.clone(), sphi1.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b113", + "sphi1" + ], + "range": { + "start": 140844, + "end": 140891 + } + }, + { + "id": "effect_1954", + "effect_id": "effect@140917:140963", + "bound_var": "b1643", + "source_text": "ctx.insert_t51_mul(b98.clone(), b1604.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1604", + "b98" + ], + "range": { + "start": 140917, + "end": 140963 + } + }, + { + "id": "effect_1955", + "effect_id": "effect@140989:141037", + "bound_var": "b1644", + "source_text": "ctx.insert_t51_add(b1642.clone(), b1643.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1642", + "b1643" + ], + "range": { + "start": 140989, + "end": 141037 + } + }, + { + "id": "effect_1956", + "effect_id": "effect@141063:141111", + "bound_var": "b1645", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1644.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1644", + "sphi2" + ], + "range": { + "start": 141063, + "end": 141111 + } + }, + { + "id": "effect_1957", + "effect_id": "effect@141137:141185", + "bound_var": "b1646", + "source_text": "ctx.insert_t51_add(b1561.clone(), b1645.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1561", + "b1645" + ], + "range": { + "start": 141137, + "end": 141185 + } + }, + { + "id": "effect_1958", + "effect_id": "effect@141211:141259", + "bound_var": "b1647", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1646.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1646", + "sphi2" + ], + "range": { + "start": 141211, + "end": 141259 + } + }, + { + "id": "effect_1959", + "effect_id": "effect@141285:141333", + "bound_var": "b1648", + "source_text": "ctx.insert_t51_add(b1618.clone(), b1647.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1618", + "b1647" + ], + "range": { + "start": 141285, + "end": 141333 + } + }, + { + "id": "effect_1960", + "effect_id": "effect@141359:141407", + "bound_var": "b1649", + "source_text": "ctx.insert_t51_add(sphi1.clone(), b1648.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1648", + "sphi1" + ], + "range": { + "start": 141359, + "end": 141407 + } + }, + { + "id": "effect_1961", + "effect_id": "effect@141433:141481", + "bound_var": "b1650", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1649.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1649", + "sphi2" + ], + "range": { + "start": 141433, + "end": 141481 + } + }, + { + "id": "effect_1962", + "effect_id": "effect@141507:141555", + "bound_var": "b1651", + "source_text": "ctx.insert_t51_add(b1544.clone(), b1650.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1544", + "b1650" + ], + "range": { + "start": 141507, + "end": 141555 + } + }, + { + "id": "effect_1963", + "effect_id": "effect@141581:141639", + "bound_var": "b1652", + "source_text": "ctx.insert_t51_lower(b1651.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1651" + ], + "range": { + "start": 141581, + "end": 141639 + } + }, + { + "id": "effect_1964", + "effect_id": "effect@141665:141715", + "bound_var": "r1653", + "source_text": "ctx.insert_t51_approx(b440.clone(), b1652.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1652", + "b440" + ], + "range": { + "start": 141665, + "end": 141715 + } + }, + { + "id": "effect_1965", + "effect_id": "effect@141729:141768", + "bound_var": null, + "source_text": "ctx.set_to_extract(1659, r1653.clone())", + "semantic_text": "to_extract(1659) = r1653", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1653" + ], + "range": { + "start": 141729, + "end": 141768 + } + }, + { + "id": "effect_1966", + "effect_id": "effect@141794:141842", + "bound_var": "b1654", + "source_text": "ctx.insert_t51_add(b1234.clone(), b1454.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1234", + "b1454" + ], + "range": { + "start": 141794, + "end": 141842 + } + }, + { + "id": "effect_1967", + "effect_id": "effect@141868:141926", + "bound_var": "b1655", + "source_text": "ctx.insert_t51_lower(b1654.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1654" + ], + "range": { + "start": 141868, + "end": 141926 + } + }, + { + "id": "effect_1968", + "effect_id": "effect@141952:142001", + "bound_var": "r1656", + "source_text": "ctx.insert_t51_approx(b19.clone(), b1655.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1655", + "b19" + ], + "range": { + "start": 141952, + "end": 142001 + } + }, + { + "id": "effect_1969", + "effect_id": "effect@142015:142054", + "bound_var": null, + "source_text": "ctx.set_to_extract(1662, r1656.clone())", + "semantic_text": "to_extract(1662) = r1656", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1656" + ], + "range": { + "start": 142015, + "end": 142054 + } + }, + { + "id": "effect_1970", + "effect_id": "effect@142080:142128", + "bound_var": "b1657", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1454.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1454", + "sphi2" + ], + "range": { + "start": 142080, + "end": 142128 + } + }, + { + "id": "effect_1971", + "effect_id": "effect@142154:142200", + "bound_var": "b1658", + "source_text": "ctx.insert_t51_mul(b65.clone(), b1657.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1657", + "b65" + ], + "range": { + "start": 142154, + "end": 142200 + } + }, + { + "id": "effect_1972", + "effect_id": "effect@142226:142271", + "bound_var": "b1659", + "source_text": "ctx.insert_t51_add(b7.clone(), b1658.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1658", + "b7" + ], + "range": { + "start": 142226, + "end": 142271 + } + }, + { + "id": "effect_1973", + "effect_id": "effect@142297:142345", + "bound_var": "b1660", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1659.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1659", + "sphi2" + ], + "range": { + "start": 142297, + "end": 142345 + } + }, + { + "id": "effect_1974", + "effect_id": "effect@142371:142419", + "bound_var": "b1661", + "source_text": "ctx.insert_t51_add(b1660.clone(), b1454.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1454", + "b1660" + ], + "range": { + "start": 142371, + "end": 142419 + } + }, + { + "id": "effect_1975", + "effect_id": "effect@142445:142503", + "bound_var": "b1662", + "source_text": "ctx.insert_t51_lower(b1661.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1661" + ], + "range": { + "start": 142445, + "end": 142503 + } + }, + { + "id": "effect_1976", + "effect_id": "effect@142529:142578", + "bound_var": "r1663", + "source_text": "ctx.insert_t51_approx(b19.clone(), b1662.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1662", + "b19" + ], + "range": { + "start": 142529, + "end": 142578 + } + }, + { + "id": "effect_1977", + "effect_id": "effect@142592:142631", + "bound_var": null, + "source_text": "ctx.set_to_extract(1669, r1663.clone())", + "semantic_text": "to_extract(1669) = r1663", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1663" + ], + "range": { + "start": 142592, + "end": 142631 + } + }, + { + "id": "effect_1978", + "effect_id": "effect@142657:142705", + "bound_var": "b1664", + "source_text": "ctx.insert_t51_add(b1462.clone(), b1515.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1462", + "b1515" + ], + "range": { + "start": 142657, + "end": 142705 + } + }, + { + "id": "effect_1979", + "effect_id": "effect@142731:142779", + "bound_var": "b1665", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1664.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1664", + "sphi2" + ], + "range": { + "start": 142731, + "end": 142779 + } + }, + { + "id": "effect_1980", + "effect_id": "effect@142805:142850", + "bound_var": "b1666", + "source_text": "ctx.insert_t51_add(b7.clone(), b1665.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1665", + "b7" + ], + "range": { + "start": 142805, + "end": 142850 + } + }, + { + "id": "effect_1981", + "effect_id": "effect@142876:142924", + "bound_var": "b1667", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1666.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1666", + "sphi2" + ], + "range": { + "start": 142876, + "end": 142924 + } + }, + { + "id": "effect_1982", + "effect_id": "effect@142950:142998", + "bound_var": "b1668", + "source_text": "ctx.insert_t51_add(b1667.clone(), b1454.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1454", + "b1667" + ], + "range": { + "start": 142950, + "end": 142998 + } + }, + { + "id": "effect_1983", + "effect_id": "effect@143024:143082", + "bound_var": "b1669", + "source_text": "ctx.insert_t51_lower(b1668.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1668" + ], + "range": { + "start": 143024, + "end": 143082 + } + }, + { + "id": "effect_1984", + "effect_id": "effect@143108:143157", + "bound_var": "r1670", + "source_text": "ctx.insert_t51_approx(b19.clone(), b1669.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1669", + "b19" + ], + "range": { + "start": 143108, + "end": 143157 + } + }, + { + "id": "effect_1985", + "effect_id": "effect@143171:143210", + "bound_var": null, + "source_text": "ctx.set_to_extract(1676, r1670.clone())", + "semantic_text": "to_extract(1676) = r1670", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1670" + ], + "range": { + "start": 143171, + "end": 143210 + } + }, + { + "id": "effect_1986", + "effect_id": "effect@143236:143291", + "bound_var": "b1671", + "source_text": "ctx.insert_t51_lower(b9.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b9" + ], + "range": { + "start": 143236, + "end": 143291 + } + }, + { + "id": "effect_1987", + "effect_id": "effect@143317:143365", + "bound_var": "r1672", + "source_text": "ctx.insert_t51_approx(b9.clone(), b1671.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1671", + "b9" + ], + "range": { + "start": 143317, + "end": 143365 + } + }, + { + "id": "effect_1988", + "effect_id": "effect@143379:143418", + "bound_var": null, + "source_text": "ctx.set_to_extract(1678, r1672.clone())", + "semantic_text": "to_extract(1678) = r1672", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1672" + ], + "range": { + "start": 143379, + "end": 143418 + } + }, + { + "id": "effect_1989", + "effect_id": "effect@143444:143490", + "bound_var": "b1673", + "source_text": "ctx.insert_t51_div(b87.clone(), b1365.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1365", + "b87" + ], + "range": { + "start": 143444, + "end": 143490 + } + }, + { + "id": "effect_1990", + "effect_id": "effect@143516:143562", + "bound_var": "b1674", + "source_text": "ctx.insert_t51_sub(b1673.clone(), b98.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1673", + "b98" + ], + "range": { + "start": 143516, + "end": 143562 + } + }, + { + "id": "effect_1991", + "effect_id": "effect@143588:143636", + "bound_var": "b1675", + "source_text": "ctx.insert_t51_mul(b1365.clone(), b1674.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1365", + "b1674" + ], + "range": { + "start": 143588, + "end": 143636 + } + }, + { + "id": "effect_1992", + "effect_id": "effect@143662:143720", + "bound_var": "b1676", + "source_text": "ctx.insert_t51_lower(b1675.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1675" + ], + "range": { + "start": 143662, + "end": 143720 + } + }, + { + "id": "effect_1993", + "effect_id": "effect@143746:143797", + "bound_var": "r1677", + "source_text": "ctx.insert_t51_approx(b1412.clone(), b1676.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1412", + "b1676" + ], + "range": { + "start": 143746, + "end": 143797 + } + }, + { + "id": "effect_1994", + "effect_id": "effect@143811:143850", + "bound_var": null, + "source_text": "ctx.set_to_extract(1683, r1677.clone())", + "semantic_text": "to_extract(1683) = r1677", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1677" + ], + "range": { + "start": 143811, + "end": 143850 + } + }, + { + "id": "effect_1995", + "effect_id": "effect@143876:143922", + "bound_var": "b1678", + "source_text": "ctx.insert_t51_div(b17.clone(), sphi2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b17", + "sphi2" + ], + "range": { + "start": 143876, + "end": 143922 + } + }, + { + "id": "effect_1996", + "effect_id": "effect@143948:143996", + "bound_var": "b1679", + "source_text": "ctx.insert_t51_add(sphi1.clone(), b1678.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1678", + "sphi1" + ], + "range": { + "start": 143948, + "end": 143996 + } + }, + { + "id": "effect_1997", + "effect_id": "effect@144022:144070", + "bound_var": "b1680", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1679.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1679", + "sphi2" + ], + "range": { + "start": 144022, + "end": 144070 + } + }, + { + "id": "effect_1998", + "effect_id": "effect@144096:144154", + "bound_var": "b1681", + "source_text": "ctx.insert_t51_lower(b1680.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1680" + ], + "range": { + "start": 144096, + "end": 144154 + } + }, + { + "id": "effect_1999", + "effect_id": "effect@144180:144230", + "bound_var": "r1682", + "source_text": "ctx.insert_t51_approx(b263.clone(), b1681.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1681", + "b263" + ], + "range": { + "start": 144180, + "end": 144230 + } + }, + { + "id": "effect_2000", + "effect_id": "effect@144244:144283", + "bound_var": null, + "source_text": "ctx.set_to_extract(1688, r1682.clone())", + "semantic_text": "to_extract(1688) = r1682", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1682" + ], + "range": { + "start": 144244, + "end": 144283 + } + }, + { + "id": "effect_2001", + "effect_id": "effect@144309:144367", + "bound_var": "b1683", + "source_text": "ctx.insert_t51_lower(b1343.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1343" + ], + "range": { + "start": 144309, + "end": 144367 + } + }, + { + "id": "effect_2002", + "effect_id": "effect@144393:144443", + "bound_var": "r1684", + "source_text": "ctx.insert_t51_approx(b316.clone(), b1683.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1683", + "b316" + ], + "range": { + "start": 144393, + "end": 144443 + } + }, + { + "id": "effect_2003", + "effect_id": "effect@144457:144496", + "bound_var": null, + "source_text": "ctx.set_to_extract(1690, r1684.clone())", + "semantic_text": "to_extract(1690) = r1684", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1684" + ], + "range": { + "start": 144457, + "end": 144496 + } + }, + { + "id": "effect_2004", + "effect_id": "effect@144522:144569", + "bound_var": "b1685", + "source_text": "ctx.insert_t51_div(b306.clone(), sphi2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b306", + "sphi2" + ], + "range": { + "start": 144522, + "end": 144569 + } + }, + { + "id": "effect_2005", + "effect_id": "effect@144595:144641", + "bound_var": "b1686", + "source_text": "ctx.insert_t51_mul(b98.clone(), b1685.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1685", + "b98" + ], + "range": { + "start": 144595, + "end": 144641 + } + }, + { + "id": "effect_2006", + "effect_id": "effect@144667:144718", + "bound_var": "b1687", + "source_text": "ctx.insert_t51_div(slambda1.clone(), sphi2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "slambda1", + "sphi2" + ], + "range": { + "start": 144667, + "end": 144718 + } + }, + { + "id": "effect_2007", + "effect_id": "effect@144744:144792", + "bound_var": "b1688", + "source_text": "ctx.insert_t51_add(b1686.clone(), b1687.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1686", + "b1687" + ], + "range": { + "start": 144744, + "end": 144792 + } + }, + { + "id": "effect_2008", + "effect_id": "effect@144818:144869", + "bound_var": "b1689", + "source_text": "ctx.insert_t51_div(slambda2.clone(), sphi2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "slambda2", + "sphi2" + ], + "range": { + "start": 144818, + "end": 144869 + } + }, + { + "id": "effect_2009", + "effect_id": "effect@144895:144941", + "bound_var": "b1690", + "source_text": "ctx.insert_t51_add(b87.clone(), b1689.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1689", + "b87" + ], + "range": { + "start": 144895, + "end": 144941 + } + }, + { + "id": "effect_2010", + "effect_id": "effect@144967:145015", + "bound_var": "b1691", + "source_text": "ctx.insert_t51_sub(b1688.clone(), b1690.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1688", + "b1690" + ], + "range": { + "start": 144967, + "end": 145015 + } + }, + { + "id": "effect_2011", + "effect_id": "effect@145041:145089", + "bound_var": "b1692", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1691.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1691", + "sphi2" + ], + "range": { + "start": 145041, + "end": 145089 + } + }, + { + "id": "effect_2012", + "effect_id": "effect@145115:145173", + "bound_var": "b1693", + "source_text": "ctx.insert_t51_lower(b1692.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1692" + ], + "range": { + "start": 145115, + "end": 145173 + } + }, + { + "id": "effect_2013", + "effect_id": "effect@145199:145249", + "bound_var": "r1694", + "source_text": "ctx.insert_t51_approx(b316.clone(), b1693.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1693", + "b316" + ], + "range": { + "start": 145199, + "end": 145249 + } + }, + { + "id": "effect_2014", + "effect_id": "effect@145263:145302", + "bound_var": null, + "source_text": "ctx.set_to_extract(1700, r1694.clone())", + "semantic_text": "to_extract(1700) = r1694", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1694" + ], + "range": { + "start": 145263, + "end": 145302 + } + }, + { + "id": "effect_2015", + "effect_id": "effect@145328:145374", + "bound_var": "b1695", + "source_text": "ctx.insert_t51_add(b87.clone(), b1688.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1688", + "b87" + ], + "range": { + "start": 145328, + "end": 145374 + } + }, + { + "id": "effect_2016", + "effect_id": "effect@145400:145448", + "bound_var": "b1696", + "source_text": "ctx.insert_t51_sub(b1695.clone(), b1689.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1689", + "b1695" + ], + "range": { + "start": 145400, + "end": 145448 + } + }, + { + "id": "effect_2017", + "effect_id": "effect@145474:145522", + "bound_var": "b1697", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1696.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1696", + "sphi2" + ], + "range": { + "start": 145474, + "end": 145522 + } + }, + { + "id": "effect_2018", + "effect_id": "effect@145548:145606", + "bound_var": "b1698", + "source_text": "ctx.insert_t51_lower(b1697.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1697" + ], + "range": { + "start": 145548, + "end": 145606 + } + }, + { + "id": "effect_2019", + "effect_id": "effect@145632:145682", + "bound_var": "r1699", + "source_text": "ctx.insert_t51_approx(b349.clone(), b1698.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1698", + "b349" + ], + "range": { + "start": 145632, + "end": 145682 + } + }, + { + "id": "effect_2020", + "effect_id": "effect@145696:145735", + "bound_var": null, + "source_text": "ctx.set_to_extract(1705, r1699.clone())", + "semantic_text": "to_extract(1705) = r1699", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1699" + ], + "range": { + "start": 145696, + "end": 145735 + } + }, + { + "id": "effect_2021", + "effect_id": "effect@145761:145807", + "bound_var": "b1700", + "source_text": "ctx.insert_t51_mul(b49.clone(), sphi1.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b49", + "sphi1" + ], + "range": { + "start": 145761, + "end": 145807 + } + }, + { + "id": "effect_2022", + "effect_id": "effect@145833:145879", + "bound_var": "b1701", + "source_text": "ctx.insert_t51_mul(b49.clone(), b1678.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1678", + "b49" + ], + "range": { + "start": 145833, + "end": 145879 + } + }, + { + "id": "effect_2023", + "effect_id": "effect@145905:145953", + "bound_var": "b1702", + "source_text": "ctx.insert_t51_add(b1700.clone(), b1701.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1700", + "b1701" + ], + "range": { + "start": 145905, + "end": 145953 + } + }, + { + "id": "effect_2024", + "effect_id": "effect@145979:146027", + "bound_var": "b1703", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1702.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1702", + "sphi2" + ], + "range": { + "start": 145979, + "end": 146027 + } + }, + { + "id": "effect_2025", + "effect_id": "effect@146053:146099", + "bound_var": "b1704", + "source_text": "ctx.insert_t51_mul(b49.clone(), b1703.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1703", + "b49" + ], + "range": { + "start": 146053, + "end": 146099 + } + }, + { + "id": "effect_2026", + "effect_id": "effect@146125:146183", + "bound_var": "b1705", + "source_text": "ctx.insert_t51_lower(b1704.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1704" + ], + "range": { + "start": 146125, + "end": 146183 + } + }, + { + "id": "effect_2027", + "effect_id": "effect@146209:146259", + "bound_var": "r1706", + "source_text": "ctx.insert_t51_approx(b263.clone(), b1705.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1705", + "b263" + ], + "range": { + "start": 146209, + "end": 146259 + } + }, + { + "id": "effect_2028", + "effect_id": "effect@146273:146312", + "bound_var": null, + "source_text": "ctx.set_to_extract(1712, r1706.clone())", + "semantic_text": "to_extract(1712) = r1706", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1706" + ], + "range": { + "start": 146273, + "end": 146312 + } + }, + { + "id": "effect_2029", + "effect_id": "effect@146338:146385", + "bound_var": "b1707", + "source_text": "ctx.insert_t51_div(b313.clone(), sphi2.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b313", + "sphi2" + ], + "range": { + "start": 146338, + "end": 146385 + } + }, + { + "id": "effect_2030", + "effect_id": "effect@146411:146457", + "bound_var": "b1708", + "source_text": "ctx.insert_t51_mul(b49.clone(), b1707.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1707", + "b49" + ], + "range": { + "start": 146411, + "end": 146457 + } + }, + { + "id": "effect_2031", + "effect_id": "effect@146483:146529", + "bound_var": "b1709", + "source_text": "ctx.insert_t51_add(b87.clone(), b1708.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1708", + "b87" + ], + "range": { + "start": 146483, + "end": 146529 + } + }, + { + "id": "effect_2032", + "effect_id": "effect@146555:146603", + "bound_var": "b1710", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1709.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1709", + "sphi2" + ], + "range": { + "start": 146555, + "end": 146603 + } + }, + { + "id": "effect_2033", + "effect_id": "effect@146629:146675", + "bound_var": "b1711", + "source_text": "ctx.insert_t51_mul(b49.clone(), b1710.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1710", + "b49" + ], + "range": { + "start": 146629, + "end": 146675 + } + }, + { + "id": "effect_2034", + "effect_id": "effect@146701:146759", + "bound_var": "b1712", + "source_text": "ctx.insert_t51_lower(b1711.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1711" + ], + "range": { + "start": 146701, + "end": 146759 + } + }, + { + "id": "effect_2035", + "effect_id": "effect@146785:146835", + "bound_var": "r1713", + "source_text": "ctx.insert_t51_approx(b316.clone(), b1712.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1712", + "b316" + ], + "range": { + "start": 146785, + "end": 146835 + } + }, + { + "id": "effect_2036", + "effect_id": "effect@146849:146888", + "bound_var": null, + "source_text": "ctx.set_to_extract(1719, r1713.clone())", + "semantic_text": "to_extract(1719) = r1713", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1713" + ], + "range": { + "start": 146849, + "end": 146888 + } + }, + { + "id": "effect_2037", + "effect_id": "effect@146914:146947", + "bound_var": "b1714", + "source_text": "ctx.insert_t51_sin(b1541.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1541" + ], + "range": { + "start": 146914, + "end": 146947 + } + }, + { + "id": "effect_2038", + "effect_id": "effect@146973:147031", + "bound_var": "b1715", + "source_text": "ctx.insert_t51_lower(b1714.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1714" + ], + "range": { + "start": 146973, + "end": 147031 + } + }, + { + "id": "effect_2039", + "effect_id": "effect@147057:147107", + "bound_var": "r1716", + "source_text": "ctx.insert_t51_approx(b324.clone(), b1715.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1715", + "b324" + ], + "range": { + "start": 147057, + "end": 147107 + } + }, + { + "id": "effect_2040", + "effect_id": "effect@147121:147160", + "bound_var": null, + "source_text": "ctx.set_to_extract(1722, r1716.clone())", + "semantic_text": "to_extract(1722) = r1716", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1716" + ], + "range": { + "start": 147121, + "end": 147160 + } + }, + { + "id": "effect_2041", + "effect_id": "effect@147186:147232", + "bound_var": "b1717", + "source_text": "ctx.insert_t51_sub(b1708.clone(), b87.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1708", + "b87" + ], + "range": { + "start": 147186, + "end": 147232 + } + }, + { + "id": "effect_2042", + "effect_id": "effect@147258:147306", + "bound_var": "b1718", + "source_text": "ctx.insert_t51_mul(sphi2.clone(), b1717.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1717", + "sphi2" + ], + "range": { + "start": 147258, + "end": 147306 + } + }, + { + "id": "effect_2043", + "effect_id": "effect@147332:147378", + "bound_var": "b1719", + "source_text": "ctx.insert_t51_mul(b49.clone(), b1718.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1718", + "b49" + ], + "range": { + "start": 147332, + "end": 147378 + } + }, + { + "id": "effect_2044", + "effect_id": "effect@147404:147462", + "bound_var": "b1720", + "source_text": "ctx.insert_t51_lower(b1719.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1719" + ], + "range": { + "start": 147404, + "end": 147462 + } + }, + { + "id": "effect_2045", + "effect_id": "effect@147488:147538", + "bound_var": "r1721", + "source_text": "ctx.insert_t51_approx(b349.clone(), b1720.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1720", + "b349" + ], + "range": { + "start": 147488, + "end": 147538 + } + }, + { + "id": "effect_2046", + "effect_id": "effect@147552:147591", + "bound_var": null, + "source_text": "ctx.set_to_extract(1727, r1721.clone())", + "semantic_text": "to_extract(1727) = r1721", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1721" + ], + "range": { + "start": 147552, + "end": 147591 + } + }, + { + "id": "effect_2047", + "effect_id": "effect@147617:147668", + "bound_var": "b1722", + "source_text": "ctx.insert_t51_add(slambda2.clone(), b1343.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1343", + "slambda2" + ], + "range": { + "start": 147617, + "end": 147668 + } + }, + { + "id": "effect_2048", + "effect_id": "effect@147694:147741", + "bound_var": "b1723", + "source_text": "ctx.insert_t51_sub(b312.clone(), b1722.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1722", + "b312" + ], + "range": { + "start": 147694, + "end": 147741 + } + }, + { + "id": "effect_2049", + "effect_id": "effect@147767:147800", + "bound_var": "b1724", + "source_text": "ctx.insert_t51_sin(b1723.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1723" + ], + "range": { + "start": 147767, + "end": 147800 + } + }, + { + "id": "effect_2050", + "effect_id": "effect@147826:147884", + "bound_var": "b1725", + "source_text": "ctx.insert_t51_lower(b1724.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1724" + ], + "range": { + "start": 147826, + "end": 147884 + } + }, + { + "id": "effect_2051", + "effect_id": "effect@147910:147960", + "bound_var": "r1726", + "source_text": "ctx.insert_t51_approx(b358.clone(), b1725.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1725", + "b358" + ], + "range": { + "start": 147910, + "end": 147960 + } + }, + { + "id": "effect_2052", + "effect_id": "effect@147974:148013", + "bound_var": null, + "source_text": "ctx.set_to_extract(1732, r1726.clone())", + "semantic_text": "to_extract(1732) = r1726", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1726" + ], + "range": { + "start": 147974, + "end": 148013 + } + }, + { + "id": "effect_2053", + "effect_id": "effect@148039:148087", + "bound_var": "b1727", + "source_text": "ctx.insert_t51_add(b1724.clone(), b1714.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1714", + "b1724" + ], + "range": { + "start": 148039, + "end": 148087 + } + }, + { + "id": "effect_2054", + "effect_id": "effect@148113:148171", + "bound_var": "b1728", + "source_text": "ctx.insert_t51_lower(b1727.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1727" + ], + "range": { + "start": 148113, + "end": 148171 + } + }, + { + "id": "effect_2055", + "effect_id": "effect@148197:148247", + "bound_var": "r1729", + "source_text": "ctx.insert_t51_approx(b383.clone(), b1728.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1728", + "b383" + ], + "range": { + "start": 148197, + "end": 148247 + } + }, + { + "id": "effect_2056", + "effect_id": "effect@148261:148300", + "bound_var": null, + "source_text": "ctx.set_to_extract(1735, r1729.clone())", + "semantic_text": "to_extract(1735) = r1729", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1729" + ], + "range": { + "start": 148261, + "end": 148300 + } + }, + { + "id": "effect_2057", + "effect_id": "effect@148326:148372", + "bound_var": "b1730", + "source_text": "ctx.insert_t51_mul(b98.clone(), b1727.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1727", + "b98" + ], + "range": { + "start": 148326, + "end": 148372 + } + }, + { + "id": "effect_2058", + "effect_id": "effect@148398:148456", + "bound_var": "b1731", + "source_text": "ctx.insert_t51_lower(b1730.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1730" + ], + "range": { + "start": 148398, + "end": 148456 + } + }, + { + "id": "effect_2059", + "effect_id": "effect@148482:148532", + "bound_var": "r1732", + "source_text": "ctx.insert_t51_approx(b416.clone(), b1731.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1731", + "b416" + ], + "range": { + "start": 148482, + "end": 148532 + } + }, + { + "id": "effect_2060", + "effect_id": "effect@148546:148585", + "bound_var": null, + "source_text": "ctx.set_to_extract(1738, r1732.clone())", + "semantic_text": "to_extract(1738) = r1732", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1732" + ], + "range": { + "start": 148546, + "end": 148585 + } + }, + { + "id": "effect_2061", + "effect_id": "effect@148611:148658", + "bound_var": "b1733", + "source_text": "ctx.insert_t51_add(b1730.clone(), b279.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1730", + "b279" + ], + "range": { + "start": 148611, + "end": 148658 + } + }, + { + "id": "effect_2062", + "effect_id": "effect@148684:148742", + "bound_var": "b1734", + "source_text": "ctx.insert_t51_lower(b1733.clone(), \"binary64\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1733" + ], + "range": { + "start": 148684, + "end": 148742 + } + }, + { + "id": "effect_2063", + "effect_id": "effect@148768:148818", + "bound_var": "r1735", + "source_text": "ctx.insert_t51_approx(b440.clone(), b1734.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "b1734", + "b440" + ], + "range": { + "start": 148768, + "end": 148818 + } + }, + { + "id": "effect_2064", + "effect_id": "effect@148832:148871", + "bound_var": null, + "source_text": "ctx.set_to_extract(1741, r1735.clone())", + "semantic_text": "to_extract(1741) = r1735", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "r1735" + ], + "range": { + "start": 148832, + "end": 148871 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "T51Var", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Num", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Pi", + "template": "pi", + "fields": [] + }, + { + "variant_name": "T51Neg", + "template": "-({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Sin", + "template": "sin({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Cos", + "template": "cos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Acos", + "template": "acos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Add", + "template": "({a0}) + ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Sub", + "template": "({a0}) - ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Mul", + "template": "({a0}) * ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Div", + "template": "frac({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Pow", + "template": "({a0})^({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Varbinary64", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Numbinary64", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Pif64Ty", + "template": "pi", + "fields": [] + }, + { + "variant_name": "T51Negf64Ty", + "template": "-({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Sinf64Ty", + "template": "sin({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Cosf64Ty", + "template": "cos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Acosf64Ty", + "template": "acos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Addf64Ty", + "template": "({a0}) + ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Subf64Ty", + "template": "({a0}) - ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Mulf64Ty", + "template": "({a0}) * ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Divf64Ty", + "template": "frac({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Powf64Ty", + "template": "({a0})^({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Lower", + "template": "lower({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Approx", + "template": "approx({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "T51Var", + "precedence": 100 + }, + { + "variant_name": "T51Num", + "precedence": 100 + }, + { + "variant_name": "T51Pi", + "precedence": 100 + }, + { + "variant_name": "T51Neg", + "precedence": 70 + }, + { + "variant_name": "T51Sin", + "precedence": 90 + }, + { + "variant_name": "T51Cos", + "precedence": 90 + }, + { + "variant_name": "T51Acos", + "precedence": 90 + }, + { + "variant_name": "T51Add", + "precedence": 50 + }, + { + "variant_name": "T51Sub", + "precedence": 50 + }, + { + "variant_name": "T51Mul", + "precedence": 60 + }, + { + "variant_name": "T51Div", + "precedence": 60 + }, + { + "variant_name": "T51Pow", + "precedence": 80 + }, + { + "variant_name": "T51Varbinary64", + "precedence": 100 + }, + { + "variant_name": "T51Numbinary64", + "precedence": 100 + }, + { + "variant_name": "T51Pif64Ty", + "precedence": 100 + }, + { + "variant_name": "T51Negf64Ty", + "precedence": 70 + }, + { + "variant_name": "T51Sinf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Cosf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Acosf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Addf64Ty", + "precedence": 50 + }, + { + "variant_name": "T51Subf64Ty", + "precedence": 50 + }, + { + "variant_name": "T51Mulf64Ty", + "precedence": 60 + }, + { + "variant_name": "T51Divf64Ty", + "precedence": 60 + }, + { + "variant_name": "T51Powf64Ty", + "precedence": 80 + }, + { + "variant_name": "T51Lower", + "precedence": 90 + }, + { + "variant_name": "T51Approx", + "precedence": 90 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "taylor51_seed", + "premises": [ + { + "target_id": "Unit", + "label": "Unit", + "plain_source": "upright(\"Unit\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_5", + "label": "tR", + "plain_source": "\"R\"", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"R\" $] $]" + }, + { + "target_id": "effect:effect_6", + "label": "tlambda1", + "plain_source": "\"upright(\"lambda1\")\"", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]" + }, + { + "target_id": "effect:effect_7", + "label": "tlambda2", + "plain_source": "\"upright(\"lambda2\")\"", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]" + }, + { + "target_id": "effect:effect_8", + "label": "tphi1", + "plain_source": "\"upright(\"phi1\")\"", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]" + }, + { + "target_id": "effect:effect_9", + "label": "tphi2", + "plain_source": "\"upright(\"phi2\")\"", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_5", + "entry": { + "target_id": "effect:effect_5", + "label": "tR", + "plain_source": "\"R\"", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"R\" $] $]" + } + }, + { + "kind": "derive", + "id": "effect_6", + "entry": { + "target_id": "effect:effect_6", + "label": "tlambda1", + "plain_source": "\"upright(\"lambda1\")\"", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]" + } + }, + { + "kind": "derive", + "id": "effect_7", + "entry": { + "target_id": "effect:effect_7", + "label": "tlambda2", + "plain_source": "\"upright(\"lambda2\")\"", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]" + } + }, + { + "kind": "derive", + "id": "effect_8", + "entry": { + "target_id": "effect:effect_8", + "label": "tphi1", + "plain_source": "\"upright(\"phi1\")\"", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]" + } + }, + { + "kind": "derive", + "id": "effect_9", + "entry": { + "target_id": "effect:effect_9", + "label": "tphi2", + "plain_source": "\"upright(\"phi2\")\"", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]" + } + }, + { + "kind": "derive", + "id": "effect_13", + "entry": { + "target_id": "effect:effect_13", + "label": "effect_13", + "plain_source": "upright(\"to_extract\")(13) = upright(\"approx\")(\"upright(\"phi1\")\", (upright(\"lower\")(\"0 / 1\", \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 13 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"0 / 1\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_16", + "entry": { + "target_id": "effect:effect_16", + "label": "effect_16", + "plain_source": "upright(\"to_extract\")(15) = upright(\"approx\")(\"R\", (upright(\"lower\")(\"R\", \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 15 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"R\" $] $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"R\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_36", + "entry": { + "target_id": "effect:effect_36", + "label": "effect_36", + "plain_source": "upright(\"to_extract\")(34) = upright(\"approx\")(((upright(\"acos\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))))) * (\"R\")), (upright(\"lower\")(((\"R\") * (upright(\"acos\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 34 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"R\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"R\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_55", + "entry": { + "target_id": "effect:effect_55", + "label": "effect_55", + "plain_source": "upright(\"to_extract\")(52) = upright(\"approx\")(((upright(\"acos\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))))))))) * (\"R\")), (upright(\"lower\")(((\"R\") * (upright(\"acos\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 52 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) $])) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"R\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"R\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_58", + "entry": { + "target_id": "effect:effect_58", + "label": "effect_58", + "plain_source": "upright(\"to_extract\")(54) = upright(\"approx\")(\"upright(\"lambda1\")\", (upright(\"lower\")(\"upright(\"lambda1\")\", \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 54 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_63", + "entry": { + "target_id": "effect:effect_63", + "label": "effect_63", + "plain_source": "upright(\"to_extract\")(58) = upright(\"approx\")(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")), (upright(\"lower\")(((\" - 1 / 1\") * (\"upright(\"lambda2\")\")), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 58 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_66", + "entry": { + "target_id": "effect:effect_66", + "label": "effect_66", + "plain_source": "upright(\"to_extract\")(60) = upright(\"approx\")(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")), (upright(\"lower\")(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 60 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_71", + "entry": { + "target_id": "effect:effect_71", + "label": "effect_71", + "plain_source": "upright(\"to_extract\")(64) = upright(\"approx\")((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")((cos((-(\"upright(\"lambda2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 64 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_78", + "entry": { + "target_id": "effect:effect_78", + "label": "effect_78", + "plain_source": "upright(\"to_extract\")(70) = upright(\"approx\")((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")(((cos((-(\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 70 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_87", + "entry": { + "target_id": "effect:effect_87", + "label": "effect_87", + "plain_source": "upright(\"to_extract\")(78) = upright(\"approx\")((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")(((cos((-(\"upright(\"lambda2\")\")))) + ((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (((\"upright(\"lambda1\")\") * (cos((-(\"upright(\"lambda2\")\"))))))) - (sin((-(\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 78 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_98", + "entry": { + "target_id": "effect:effect_98", + "label": "effect_98", + "plain_source": "upright(\"to_extract\")(88) = upright(\"approx\")((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")(((cos((-(\"upright(\"lambda2\")\")))) + ((\"upright(\"lambda1\")\") * ((((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (cos((-(\"upright(\"lambda2\")\"))))) + ((\"1 / 6\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\")))))))))) - (sin((-(\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 88 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_101", + "entry": { + "target_id": "effect:effect_101", + "label": "effect_101", + "plain_source": "upright(\"to_extract\")(90) = upright(\"approx\")(((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 90 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_104", + "entry": { + "target_id": "effect:effect_104", + "label": "effect_104", + "plain_source": "upright(\"to_extract\")(92) = upright(\"approx\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))))), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 92 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_108", + "entry": { + "target_id": "effect:effect_108", + "label": "effect_108", + "plain_source": "upright(\"to_extract\")(95) = upright(\"approx\")((cos(\"upright(\"lambda1\")\")), (upright(\"lower\")(\"1 / 1\", \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 95 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_115", + "entry": { + "target_id": "effect:effect_115", + "label": "effect_115", + "plain_source": "upright(\"to_extract\")(101) = upright(\"approx\")((cos(\"upright(\"lambda1\")\")), (upright(\"lower\")(((\"1 / 1\") + ((\" - 1 / 2\") * ((\"upright(\"lambda1\")\")^(\"2 / 1\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 101 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_124", + "entry": { + "target_id": "effect:effect_124", + "label": "effect_124", + "plain_source": "upright(\"to_extract\")(109) = upright(\"approx\")((cos(\"upright(\"lambda1\")\")), (upright(\"lower\")(((\"1 / 1\") + (((\"upright(\"lambda1\")\")^(\"2 / 1\")) * ((((\"1 / 24\") * ((\"upright(\"lambda1\")\")^(\"2 / 1\"))) - (\"1 / 2\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 109 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_134", + "entry": { + "target_id": "effect:effect_134", + "label": "effect_134", + "plain_source": "upright(\"to_extract\")(118) = upright(\"approx\")((cos(\"upright(\"lambda1\")\")), (upright(\"lower\")(((\"1 / 1\") + (((\"upright(\"lambda1\")\")^(\"2 / 1\")) * (((((\"upright(\"lambda1\")\")^(\"2 / 1\")) * (((\"1 / 24\") + ((\" - 1 / 720\") * ((\"upright(\"lambda1\")\")^(\"2 / 1\")))))) - (\"1 / 2\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 118 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 720\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_141", + "entry": { + "target_id": "effect:effect_141", + "label": "effect_141", + "plain_source": "upright(\"to_extract\")(124) = upright(\"approx\")((sin(\"upright(\"lambda1\")\")), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (((\"1 / 1\") + ((\" - 1 / 6\") * ((\"upright(\"lambda1\")\")^(\"2 / 1\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 124 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_150", + "entry": { + "target_id": "effect:effect_150", + "label": "effect_150", + "plain_source": "upright(\"to_extract\")(132) = upright(\"approx\")((sin(\"upright(\"lambda1\")\")), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (((\"1 / 1\") + (((\"upright(\"lambda1\")\")^(\"2 / 1\")) * ((((\"1 / 120\") * ((\"upright(\"lambda1\")\")^(\"2 / 1\"))) - (\"1 / 6\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 132 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_161", + "entry": { + "target_id": "effect:effect_161", + "label": "effect_161", + "plain_source": "upright(\"to_extract\")(142) = upright(\"approx\")((sin(\"upright(\"lambda1\")\")), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (((\"1 / 1\") + (((\"upright(\"lambda1\")\")^(\"2 / 1\")) * (((((\"upright(\"lambda1\")\")^(\"2 / 1\")) * (((\"1 / 120\") + ((\" - 1 / 5040\") * ((\"upright(\"lambda1\")\")^(\"2 / 1\")))))) - (\"1 / 6\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 142 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 5040\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_165", + "entry": { + "target_id": "effect:effect_165", + "label": "effect_165", + "plain_source": "upright(\"to_extract\")(145) = upright(\"approx\")(((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (sin(\"upright(\"lambda2\")\"))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 145 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_172", + "entry": { + "target_id": "effect:effect_172", + "label": "effect_172", + "plain_source": "upright(\"to_extract\")(151) = upright(\"approx\")(((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (((sin(\"upright(\"lambda2\")\")) + ((\" - 1 / 6\") * ((((\"upright(\"lambda1\")\")^(\"2 / 1\")) * (sin(\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 151 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_181", + "entry": { + "target_id": "effect:effect_181", + "label": "effect_181", + "plain_source": "upright(\"to_extract\")(159) = upright(\"approx\")(((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (((sin(\"upright(\"lambda2\")\")) + (((\"upright(\"lambda1\")\")^(\"2 / 1\")) * ((((\" - 1 / 6\") * (sin(\"upright(\"lambda2\")\"))) + ((\"1 / 120\") * ((((\"upright(\"lambda1\")\")^(\"2 / 1\")) * (sin(\"upright(\"lambda2\")\"))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 159 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_192", + "entry": { + "target_id": "effect:effect_192", + "label": "effect_192", + "plain_source": "upright(\"to_extract\")(169) = upright(\"approx\")(((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (((sin(\"upright(\"lambda2\")\")) + (((\"upright(\"lambda1\")\")^(\"2 / 1\")) * ((((\" - 1 / 6\") * (sin(\"upright(\"lambda2\")\"))) + (((\"upright(\"lambda1\")\")^(\"2 / 1\")) * ((((\" - 1 / 5040\") * ((((\"upright(\"lambda1\")\")^(\"2 / 1\")) * (sin(\"upright(\"lambda2\")\"))))) + ((\"1 / 120\") * (sin(\"upright(\"lambda2\")\")))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 169 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 5040\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_195", + "entry": { + "target_id": "effect:effect_195", + "label": "effect_195", + "plain_source": "upright(\"to_extract\")(171) = upright(\"approx\")((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))), (upright(\"lower\")((cos(\"upright(\"lambda2\")\")), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 171 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_199", + "entry": { + "target_id": "effect:effect_199", + "label": "effect_199", + "plain_source": "upright(\"to_extract\")(174) = upright(\"approx\")((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))), (upright(\"lower\")(((cos(\"upright(\"lambda2\")\")) + ((\"upright(\"lambda1\")\") * (sin(\"upright(\"lambda2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 174 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_207", + "entry": { + "target_id": "effect:effect_207", + "label": "effect_207", + "plain_source": "upright(\"to_extract\")(181) = upright(\"approx\")((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))), (upright(\"lower\")(((cos(\"upright(\"lambda2\")\")) + ((\"upright(\"lambda1\")\") * (((sin(\"upright(\"lambda2\")\")) + ((\" - 1 / 2\") * (((\"upright(\"lambda1\")\") * (cos(\"upright(\"lambda2\")\"))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 181 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_217", + "entry": { + "target_id": "effect:effect_217", + "label": "effect_217", + "plain_source": "upright(\"to_extract\")(190) = upright(\"approx\")((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))), (upright(\"lower\")(((cos(\"upright(\"lambda2\")\")) + ((\"upright(\"lambda1\")\") * (((sin(\"upright(\"lambda2\")\")) + ((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (cos(\"upright(\"lambda2\")\"))) + ((\" - 1 / 6\") * (((\"upright(\"lambda1\")\") * (sin(\"upright(\"lambda2\")\")))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 190 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_222", + "entry": { + "target_id": "effect:effect_222", + "label": "effect_222", + "plain_source": "upright(\"to_extract\")(194) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")(((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 194 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_230", + "entry": { + "target_id": "effect:effect_230", + "label": "effect_230", + "plain_source": "upright(\"to_extract\")(201) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")((((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin((-(\"upright(\"lambda2\")\"))))))))))) + ((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 201 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_239", + "entry": { + "target_id": "effect:effect_239", + "label": "effect_239", + "plain_source": "upright(\"to_extract\")(209) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")((((\"upright(\"lambda1\")\") * ((((\" - 1 / 1\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin((-(\"upright(\"lambda2\")\"))))))))) + ((\" - 1 / 2\") * (((\"upright(\"lambda1\")\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\")))))))))))))) + ((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 209 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_249", + "entry": { + "target_id": "effect:effect_249", + "label": "effect_249", + "plain_source": "upright(\"to_extract\")(218) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")((((\"upright(\"lambda1\")\") * ((((\" - 1 / 1\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin((-(\"upright(\"lambda2\")\"))))))))) + ((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\"))))))))) + ((\"1 / 6\") * (((\"upright(\"lambda1\")\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin((-(\"upright(\"lambda2\")\"))))))))))))))))) + ((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 218 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $])) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_253", + "entry": { + "target_id": "effect:effect_253", + "label": "effect_253", + "plain_source": "upright(\"to_extract\")(221) = upright(\"approx\")(((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), (upright(\"lower\")(((cos(\"upright(\"lambda2\")\")) * (cos(\"upright(\"phi2\")\"))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 221 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_259", + "entry": { + "target_id": "effect:effect_259", + "label": "effect_259", + "plain_source": "upright(\"to_extract\")(226) = upright(\"approx\")(((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"lambda1\")\") * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda2\")\"))))) + ((cos(\"upright(\"lambda2\")\")) * (cos(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 226 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_267", + "entry": { + "target_id": "effect:effect_267", + "label": "effect_267", + "plain_source": "upright(\"to_extract\")(233) = upright(\"approx\")(((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (((\"upright(\"lambda1\")\") * (((cos(\"upright(\"lambda2\")\")) * (cos(\"upright(\"phi2\")\"))))))) + ((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda2\")\")))))) + ((cos(\"upright(\"lambda2\")\")) * (cos(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 233 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_277", + "entry": { + "target_id": "effect:effect_277", + "label": "effect_277", + "plain_source": "upright(\"to_extract\")(242) = upright(\"approx\")(((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"lambda1\")\") * ((((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (((cos(\"upright(\"lambda2\")\")) * (cos(\"upright(\"phi2\")\"))))) + ((\" - 1 / 6\") * (((\"upright(\"lambda1\")\") * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda2\")\")))))))))) + ((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda2\")\")))))) + ((cos(\"upright(\"lambda2\")\")) * (cos(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 242 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_282", + "entry": { + "target_id": "effect:effect_282", + "label": "effect_282", + "plain_source": "upright(\"to_extract\")(246) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((cos(\"upright(\"lambda2\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 246 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_288", + "entry": { + "target_id": "effect:effect_288", + "label": "effect_288", + "plain_source": "upright(\"to_extract\")(251) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((\"upright(\"lambda1\")\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda2\")\"))))))) + ((((cos(\"upright(\"lambda2\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 251 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_296", + "entry": { + "target_id": "effect:effect_296", + "label": "effect_296", + "plain_source": "upright(\"to_extract\")(258) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (((\"upright(\"lambda1\")\") * (((cos(\"upright(\"lambda2\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))))))) + ((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((((cos(\"upright(\"lambda2\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 258 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_306", + "entry": { + "target_id": "effect:effect_306", + "label": "effect_306", + "plain_source": "upright(\"to_extract\")(267) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((\"upright(\"lambda1\")\") * ((((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (((cos(\"upright(\"lambda2\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))))) + ((\" - 1 / 6\") * (((\"upright(\"lambda1\")\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda2\")\")))))))))))) + ((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((((cos(\"upright(\"lambda2\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 267 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_312", + "entry": { + "target_id": "effect:effect_312", + "label": "effect_312", + "plain_source": "upright(\"to_extract\")(272) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos((-(\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 272 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_317", + "entry": { + "target_id": "effect:effect_317", + "label": "effect_317", + "plain_source": "upright(\"to_extract\")(276) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos((-(\"upright(\"lambda2\")\")))) + ((((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 276 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_322", + "entry": { + "target_id": "effect:effect_322", + "label": "effect_322", + "plain_source": "upright(\"to_extract\")(280) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos((-(\"upright(\"lambda2\")\")))) + ((((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (((\"upright(\"lambda1\")\") * (cos((-(\"upright(\"lambda2\")\"))))))) - (sin((-(\"upright(\"lambda2\")\"))))))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 280 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_327", + "entry": { + "target_id": "effect:effect_327", + "label": "effect_327", + "plain_source": "upright(\"to_extract\")(284) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos((-(\"upright(\"lambda2\")\")))) + ((((\"upright(\"lambda1\")\") * ((((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (cos((-(\"upright(\"lambda2\")\"))))) + ((\"1 / 6\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\")))))))))) - (sin((-(\"upright(\"lambda2\")\"))))))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 284 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_333", + "entry": { + "target_id": "effect:effect_333", + "label": "effect_333", + "plain_source": "upright(\"to_extract\")(289) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 289 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_339", + "entry": { + "target_id": "effect:effect_339", + "label": "effect_339", + "plain_source": "upright(\"to_extract\")(294) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (((cos(\"upright(\"phi2\")\")) * (sin((-(\"upright(\"lambda2\")\"))))))))) + ((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 294 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_348", + "entry": { + "target_id": "effect:effect_348", + "label": "effect_348", + "plain_source": "upright(\"to_extract\")(302) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"lambda1\")\") * ((((\" - 1 / 1\") * (((cos(\"upright(\"phi2\")\")) * (sin((-(\"upright(\"lambda2\")\"))))))) + ((\" - 1 / 2\") * (((\"upright(\"lambda1\")\") * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\")))))))))))) + ((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 302 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_358", + "entry": { + "target_id": "effect:effect_358", + "label": "effect_358", + "plain_source": "upright(\"to_extract\")(311) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"lambda1\")\") * ((((\" - 1 / 1\") * (((cos(\"upright(\"phi2\")\")) * (sin((-(\"upright(\"lambda2\")\"))))))) + ((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\"))))))) + ((\"1 / 6\") * (((\"upright(\"lambda1\")\") * (((cos(\"upright(\"phi2\")\")) * (sin((-(\"upright(\"lambda2\")\"))))))))))))))) + ((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 311 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) $])) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_365", + "entry": { + "target_id": "effect:effect_365", + "label": "effect_365", + "plain_source": "upright(\"to_extract\")(317) = upright(\"approx\")((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")((((\"1 / 2\") * (upright(\"pi\"))) - (\"upright(\"lambda2\")\")), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 317 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_370", + "entry": { + "target_id": "effect:effect_370", + "label": "effect_370", + "plain_source": "upright(\"to_extract\")(321) = upright(\"approx\")((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 321 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_376", + "entry": { + "target_id": "effect:effect_376", + "label": "effect_376", + "plain_source": "upright(\"to_extract\")(326) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")), (upright(\"lower\")((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 326 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_380", + "entry": { + "target_id": "effect:effect_380", + "label": "effect_380", + "plain_source": "upright(\"to_extract\")(329) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")), (upright(\"lower\")(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 329 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_385", + "entry": { + "target_id": "effect:effect_385", + "label": "effect_385", + "plain_source": "upright(\"to_extract\")(333) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 333 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_391", + "entry": { + "target_id": "effect:effect_391", + "label": "effect_391", + "plain_source": "upright(\"to_extract\")(338) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + ((\"upright(\"lambda1\")\") * (cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 338 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_399", + "entry": { + "target_id": "effect:effect_399", + "label": "effect_399", + "plain_source": "upright(\"to_extract\")(345) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + ((\"upright(\"lambda1\")\") * (((cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + ((\" - 1 / 2\") * (((\"upright(\"lambda1\")\") * (sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\"))))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 345 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_409", + "entry": { + "target_id": "effect:effect_409", + "label": "effect_409", + "plain_source": "upright(\"to_extract\")(354) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + ((\"upright(\"lambda1\")\") * (((cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + ((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\"))))))) + ((\" - 1 / 6\") * (((\"upright(\"lambda1\")\") * (cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 354 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_415", + "entry": { + "target_id": "effect:effect_415", + "label": "effect_415", + "plain_source": "upright(\"to_extract\")(359) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")), (upright(\"lower\")(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 359 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_420", + "entry": { + "target_id": "effect:effect_420", + "label": "effect_420", + "plain_source": "upright(\"to_extract\")(363) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")), (upright(\"lower\")(((((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"lambda2\")\")), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 363 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_425", + "entry": { + "target_id": "effect:effect_425", + "label": "effect_425", + "plain_source": "upright(\"to_extract\")(367) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")((sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 367 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_431", + "entry": { + "target_id": "effect:effect_431", + "label": "effect_431", + "plain_source": "upright(\"to_extract\")(372) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"lambda1\")\") * (cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 372 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_439", + "entry": { + "target_id": "effect:effect_439", + "label": "effect_439", + "plain_source": "upright(\"to_extract\")(379) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"lambda1\")\") * (((cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\" - 1 / 2\") * (((\"upright(\"lambda1\")\") * (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 379 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_449", + "entry": { + "target_id": "effect:effect_449", + "label": "effect_449", + "plain_source": "upright(\"to_extract\")(388) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"lambda1\")\") * (((cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\" - 1 / 6\") * (((\"upright(\"lambda1\")\") * (cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 388 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_454", + "entry": { + "target_id": "effect:effect_454", + "label": "effect_454", + "plain_source": "upright(\"to_extract\")(392) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")(((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 392 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_461", + "entry": { + "target_id": "effect:effect_461", + "label": "effect_461", + "plain_source": "upright(\"to_extract\")(398) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")(((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (((sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"lambda1\")\") * (((cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 398 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_471", + "entry": { + "target_id": "effect:effect_471", + "label": "effect_471", + "plain_source": "upright(\"to_extract\")(407) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")(((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (((sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"lambda1\")\") * (((cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (((cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\"))))))) + ((\" - 1 / 2\") * (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 407 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) $])) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_486", + "entry": { + "target_id": "effect:effect_486", + "label": "effect_486", + "plain_source": "upright(\"to_extract\")(421) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")(((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (((sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"lambda1\")\") * (((cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (((cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\"))))))) + ((((\" - 1 / 2\") * (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\"upright(\"lambda1\")\") * ((((\" - 1 / 6\") * (cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\"))))))) + ((\" - 1 / 6\") * (cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))))))))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 421 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) $])) $])) $]) $])) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_491", + "entry": { + "target_id": "effect:effect_491", + "label": "effect_491", + "plain_source": "upright(\"to_extract\")(425) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")(((\"1 / 2\") * (((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 425 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_496", + "entry": { + "target_id": "effect:effect_496", + "label": "effect_496", + "plain_source": "upright(\"to_extract\")(429) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")((((\"1 / 2\") * (((\"upright(\"lambda1\")\") * (((cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))))) + ((\"1 / 2\") * (((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 429 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_504", + "entry": { + "target_id": "effect:effect_504", + "label": "effect_504", + "plain_source": "upright(\"to_extract\")(436) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")((((\"1 / 2\") * (((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))) + ((\"upright(\"lambda1\")\") * ((((\"1 / 2\") * (((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\"))))))) + ((\" - 1 / 2\") * (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))) + ((\"1 / 2\") * (((cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 436 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_514", + "entry": { + "target_id": "effect:effect_514", + "label": "effect_514", + "plain_source": "upright(\"to_extract\")(445) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")((((\"1 / 2\") * (((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))) + ((\"upright(\"lambda1\")\") * ((((\"1 / 2\") * (((cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))) + ((\"upright(\"lambda1\")\") * ((((\"1 / 2\") * (((\"upright(\"lambda1\")\") * ((((\" - 1 / 6\") * (cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\"))))))) + ((\" - 1 / 6\") * (cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))) + ((\"1 / 2\") * ((((\" - 1 / 2\") * (sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\"))))))) + ((\" - 1 / 2\") * (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 445 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_519", + "entry": { + "target_id": "effect:effect_519", + "label": "effect_519", + "plain_source": "upright(\"to_extract\")(449) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")((((\"1 / 2\") * (((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))) + ((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 449 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_523", + "entry": { + "target_id": "effect:effect_523", + "label": "effect_523", + "plain_source": "upright(\"to_extract\")(452) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")((((\"1 / 2\") * (((\"upright(\"lambda1\")\") * (((cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))))) + ((((\"1 / 2\") * (((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))) + ((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 452 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_528", + "entry": { + "target_id": "effect:effect_528", + "label": "effect_528", + "plain_source": "upright(\"to_extract\")(456) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")((((\"1 / 2\") * (((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))) + ((((\"upright(\"lambda1\")\") * ((((\"1 / 2\") * (((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\"))))))) + ((\" - 1 / 2\") * (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))) + ((\"1 / 2\") * (((cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))) + ((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 456 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_533", + "entry": { + "target_id": "effect:effect_533", + "label": "effect_533", + "plain_source": "upright(\"to_extract\")(460) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")((((\"1 / 2\") * (((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))) + ((((\"upright(\"lambda1\")\") * ((((\"1 / 2\") * (((cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))) + ((\"upright(\"lambda1\")\") * ((((\"1 / 2\") * (((\"upright(\"lambda1\")\") * ((((\" - 1 / 6\") * (cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\"))))))) + ((\" - 1 / 6\") * (cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))) + ((\"1 / 2\") * ((((\" - 1 / 2\") * (sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\"))))))) + ((\" - 1 / 2\") * (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))))))) + ((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 460 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_537", + "entry": { + "target_id": "effect:effect_537", + "label": "effect_537", + "plain_source": "upright(\"to_extract\")(463) = upright(\"approx\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\"))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 463 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_541", + "entry": { + "target_id": "effect:effect_541", + "label": "effect_541", + "plain_source": "upright(\"to_extract\")(466) = upright(\"approx\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin((-(\"upright(\"lambda2\")\"))))))))))) + ((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\"))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 466 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_545", + "entry": { + "target_id": "effect:effect_545", + "label": "effect_545", + "plain_source": "upright(\"to_extract\")(469) = upright(\"approx\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"lambda1\")\") * ((((\" - 1 / 1\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin((-(\"upright(\"lambda2\")\"))))))))) + ((\" - 1 / 2\") * (((\"upright(\"lambda1\")\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\")))))))))))))) + ((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\"))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 469 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $])) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_549", + "entry": { + "target_id": "effect:effect_549", + "label": "effect_549", + "plain_source": "upright(\"to_extract\")(472) = upright(\"approx\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"lambda1\")\") * ((((\" - 1 / 1\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin((-(\"upright(\"lambda2\")\"))))))))) + ((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\"))))))))) + ((\"1 / 6\") * (((\"upright(\"lambda1\")\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin((-(\"upright(\"lambda2\")\"))))))))))))))))) + ((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\"))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 472 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $])) $]) $])) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_552", + "entry": { + "target_id": "effect:effect_552", + "label": "effect_552", + "plain_source": "upright(\"to_extract\")(474) = upright(\"approx\")((upright(\"acos\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))))), (upright(\"lower\")((upright(\"acos\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 474 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_555", + "entry": { + "target_id": "effect:effect_555", + "label": "effect_555", + "plain_source": "upright(\"to_extract\")(476) = upright(\"approx\")((upright(\"acos\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))))))))), (upright(\"lower\")((upright(\"acos\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 476 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_562", + "entry": { + "target_id": "effect:effect_562", + "label": "effect_562", + "plain_source": "upright(\"to_extract\")(482) = upright(\"approx\")(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (((\"1 / 1\") + ((\" - 1 / 1\") * ((frac(\"upright(\"lambda2\")\", \"upright(\"lambda1\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 482 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_565", + "entry": { + "target_id": "effect:effect_565", + "label": "effect_565", + "plain_source": "upright(\"to_extract\")(484) = upright(\"approx\")((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 484 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_572", + "entry": { + "target_id": "effect:effect_572", + "label": "effect_572", + "plain_source": "upright(\"to_extract\")(490) = upright(\"approx\")(((cos((-(\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\")))))))), (upright(\"lower\")(((\"upright(\"lambda1\")\") * ((((\" - 1 / 1\") * (sin((-(\"upright(\"lambda2\")\"))))) + (frac(cos((-(\"upright(\"lambda2\")\"))), \"upright(\"lambda1\")\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 490 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_575", + "entry": { + "target_id": "effect:effect_575", + "label": "effect_575", + "plain_source": "upright(\"to_extract\")(492) = upright(\"approx\")((cos(\"upright(\"lambda1\")\")), (upright(\"lower\")((cos(\"upright(\"lambda1\")\")), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 492 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_578", + "entry": { + "target_id": "effect:effect_578", + "label": "effect_578", + "plain_source": "upright(\"to_extract\")(494) = upright(\"approx\")((sin(\"upright(\"lambda1\")\")), (upright(\"lower\")((sin(\"upright(\"lambda1\")\")), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 494 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_581", + "entry": { + "target_id": "effect:effect_581", + "label": "effect_581", + "plain_source": "upright(\"to_extract\")(496) = upright(\"approx\")(((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))), (upright(\"lower\")(((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 496 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_584", + "entry": { + "target_id": "effect:effect_584", + "label": "effect_584", + "plain_source": "upright(\"to_extract\")(498) = upright(\"approx\")((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))), (upright(\"lower\")((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 498 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_587", + "entry": { + "target_id": "effect:effect_587", + "label": "effect_587", + "plain_source": "upright(\"to_extract\")(500) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")(((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 500 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_590", + "entry": { + "target_id": "effect:effect_590", + "label": "effect_590", + "plain_source": "upright(\"to_extract\")(502) = upright(\"approx\")(((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), (upright(\"lower\")(((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 502 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_593", + "entry": { + "target_id": "effect:effect_593", + "label": "effect_593", + "plain_source": "upright(\"to_extract\")(504) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 504 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_596", + "entry": { + "target_id": "effect:effect_596", + "label": "effect_596", + "plain_source": "upright(\"to_extract\")(506) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 506 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_599", + "entry": { + "target_id": "effect:effect_599", + "label": "effect_599", + "plain_source": "upright(\"to_extract\")(508) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 508 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_607", + "entry": { + "target_id": "effect:effect_607", + "label": "effect_607", + "plain_source": "upright(\"to_extract\")(515) = upright(\"approx\")((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (((((\"1 / 1\") + ((\"1 / 2\") * ((frac(upright(\"pi\"), \"upright(\"lambda1\")\")))))) - (frac(\"upright(\"lambda2\")\", \"upright(\"lambda1\")\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 515 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $])) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_614", + "entry": { + "target_id": "effect:effect_614", + "label": "effect_614", + "plain_source": "upright(\"to_extract\")(521) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (((((\"1 / 1\") + ((\"1 / 2\") * ((frac(upright(\"pi\"), \"upright(\"lambda1\")\")))))) - (((frac(\"upright(\"lambda2\")\", \"upright(\"lambda1\")\")) + (frac(\"upright(\"phi2\")\", \"upright(\"lambda1\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 521 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $])) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_618", + "entry": { + "target_id": "effect:effect_618", + "label": "effect_618", + "plain_source": "upright(\"to_extract\")(524) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 524 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_625", + "entry": { + "target_id": "effect:effect_625", + "label": "effect_625", + "plain_source": "upright(\"to_extract\")(530) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (((((\"1 / 1\") + ((((\"1 / 2\") * ((frac(upright(\"pi\"), \"upright(\"lambda1\")\")))) + (frac(\"upright(\"phi2\")\", \"upright(\"lambda1\")\")))))) - (frac(\"upright(\"lambda2\")\", \"upright(\"lambda1\")\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 530 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_629", + "entry": { + "target_id": "effect:effect_629", + "label": "effect_629", + "plain_source": "upright(\"to_extract\")(533) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")((sin(((((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"lambda2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 533 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_633", + "entry": { + "target_id": "effect:effect_633", + "label": "effect_633", + "plain_source": "upright(\"to_extract\")(536) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"lambda2\")\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 536 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_637", + "entry": { + "target_id": "effect:effect_637", + "label": "effect_637", + "plain_source": "upright(\"to_extract\")(539) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")(((\"1 / 2\") * (((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 539 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_641", + "entry": { + "target_id": "effect:effect_641", + "label": "effect_641", + "plain_source": "upright(\"to_extract\")(542) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")((((\"1 / 2\") * (((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"lambda2\")\"))))))) + ((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 542 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_644", + "entry": { + "target_id": "effect:effect_644", + "label": "effect_644", + "plain_source": "upright(\"to_extract\")(544) = upright(\"approx\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 544 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_650", + "entry": { + "target_id": "effect:effect_650", + "label": "effect_650", + "plain_source": "upright(\"to_extract\")(549) = upright(\"approx\")(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (((frac(\"upright(\"lambda2\")\", \"upright(\"lambda1\")\")) - (\"1 / 1\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 549 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_657", + "entry": { + "target_id": "effect:effect_657", + "label": "effect_657", + "plain_source": "upright(\"to_extract\")(555) = upright(\"approx\")((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")((cos((-(((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 555 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_664", + "entry": { + "target_id": "effect:effect_664", + "label": "effect_664", + "plain_source": "upright(\"to_extract\")(561) = upright(\"approx\")(((cos((-(\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\")))))))), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (((sin((-(\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * ((frac(cos((-(\"upright(\"lambda2\")\"))), \"upright(\"lambda1\")\"))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 561 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $])) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_669", + "entry": { + "target_id": "effect:effect_669", + "label": "effect_669", + "plain_source": "upright(\"to_extract\")(565) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")(((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\")))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 565 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_673", + "entry": { + "target_id": "effect:effect_673", + "label": "effect_673", + "plain_source": "upright(\"to_extract\")(568) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos((-(((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\"))))))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 568 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_677", + "entry": { + "target_id": "effect:effect_677", + "label": "effect_677", + "plain_source": "upright(\"to_extract\")(571) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos((-(((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\"))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 571 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_685", + "entry": { + "target_id": "effect:effect_685", + "label": "effect_685", + "plain_source": "upright(\"to_extract\")(578) = upright(\"approx\")((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * ((((\" - 1 / 1\") * ((frac((((\"1 / 2\") * (upright(\"pi\"))) - (\"upright(\"lambda2\")\")), \"upright(\"lambda1\")\")))) - (\"1 / 1\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 578 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_693", + "entry": { + "target_id": "effect:effect_693", + "label": "effect_693", + "plain_source": "upright(\"to_extract\")(585) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * ((((\" - 1 / 1\") * ((frac((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))), \"upright(\"lambda1\")\")))) - (\"1 / 1\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 585 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_700", + "entry": { + "target_id": "effect:effect_700", + "label": "effect_700", + "plain_source": "upright(\"to_extract\")(591) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (((\"upright(\"phi2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\"))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 591 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_708", + "entry": { + "target_id": "effect:effect_708", + "label": "effect_708", + "plain_source": "upright(\"to_extract\")(598) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * ((((\" - 1 / 1\") * ((frac(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")), \"upright(\"lambda1\")\")))) - (\"1 / 1\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 598 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_713", + "entry": { + "target_id": "effect:effect_713", + "label": "effect_713", + "plain_source": "upright(\"to_extract\")(602) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")((sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 602 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_717", + "entry": { + "target_id": "effect:effect_717", + "label": "effect_717", + "plain_source": "upright(\"to_extract\")(605) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")(((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (((\"upright(\"phi2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\"))))))))) + (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\")))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 605 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_721", + "entry": { + "target_id": "effect:effect_721", + "label": "effect_721", + "plain_source": "upright(\"to_extract\")(608) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")(((\"1 / 2\") * (((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (((\"upright(\"phi2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\"))))))))) + (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\")))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 608 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_725", + "entry": { + "target_id": "effect:effect_725", + "label": "effect_725", + "plain_source": "upright(\"to_extract\")(611) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")((((\"1 / 2\") * (((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (((\"upright(\"phi2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\"))))))))) + (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\")))))))))) + ((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 611 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_729", + "entry": { + "target_id": "effect:effect_729", + "label": "effect_729", + "plain_source": "upright(\"to_extract\")(614) = upright(\"approx\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\")))))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 614 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_733", + "entry": { + "target_id": "effect:effect_733", + "label": "effect_733", + "plain_source": "upright(\"to_extract\")(617) = upright(\"approx\")((upright(\"acos\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))))), (upright(\"lower\")((upright(\"acos\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\")))))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 617 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_737", + "entry": { + "target_id": "effect:effect_737", + "label": "effect_737", + "plain_source": "upright(\"to_extract\")(620) = upright(\"approx\")(((upright(\"acos\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))))) * (\"R\")), (upright(\"lower\")(((\"R\") * (upright(\"acos\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\")))))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 620 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"R\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"R\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_740", + "entry": { + "target_id": "effect:effect_740", + "label": "effect_740", + "plain_source": "upright(\"to_extract\")(622) = upright(\"approx\")(\"upright(\"lambda2\")\", (upright(\"lower\")(\"upright(\"lambda2\")\", \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 622 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_744", + "entry": { + "target_id": "effect:effect_744", + "label": "effect_744", + "plain_source": "upright(\"to_extract\")(625) = upright(\"approx\")(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")), (upright(\"lower\")(((\"upright(\"lambda1\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda2\")\"))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 625 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_749", + "entry": { + "target_id": "effect:effect_749", + "label": "effect_749", + "plain_source": "upright(\"to_extract\")(629) = upright(\"approx\")((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")(((cos(\"upright(\"lambda1\")\")) + ((\"upright(\"lambda2\")\") * (sin(\"upright(\"lambda1\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 629 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_758", + "entry": { + "target_id": "effect:effect_758", + "label": "effect_758", + "plain_source": "upright(\"to_extract\")(637) = upright(\"approx\")((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")(((cos(\"upright(\"lambda1\")\")) + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (((\"upright(\"lambda2\")\") * (cos(\"upright(\"lambda1\")\"))))) - ((\" - 1 / 1\") * (sin(\"upright(\"lambda1\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 637 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_768", + "entry": { + "target_id": "effect:effect_768", + "label": "effect_768", + "plain_source": "upright(\"to_extract\")(646) = upright(\"approx\")((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")(((cos(\"upright(\"lambda1\")\")) + ((\"upright(\"lambda2\")\") * ((((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (cos(\"upright(\"lambda1\")\"))) + ((\" - 1 / 6\") * (((\"upright(\"lambda2\")\") * (sin(\"upright(\"lambda1\")\")))))))) - ((\" - 1 / 1\") * (sin(\"upright(\"lambda1\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 646 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_774", + "entry": { + "target_id": "effect:effect_774", + "label": "effect_774", + "plain_source": "upright(\"to_extract\")(651) = upright(\"approx\")((cos((-(\"upright(\"lambda2\")\")))), (upright(\"lower\")(((\"1 / 1\") + ((\" - 1 / 2\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 651 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_781", + "entry": { + "target_id": "effect:effect_781", + "label": "effect_781", + "plain_source": "upright(\"to_extract\")(657) = upright(\"approx\")((cos((-(\"upright(\"lambda2\")\")))), (upright(\"lower\")(((\"1 / 1\") + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * ((((\"1 / 24\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\"))) - (\"1 / 2\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 657 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_790", + "entry": { + "target_id": "effect:effect_790", + "label": "effect_790", + "plain_source": "upright(\"to_extract\")(665) = upright(\"approx\")((cos((-(\"upright(\"lambda2\")\")))), (upright(\"lower\")(((\"1 / 1\") + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * (((((\"upright(\"lambda2\")\")^(\"2 / 1\")) * (((\"1 / 24\") + ((\" - 1 / 720\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\")))))) - (\"1 / 2\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 665 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 720\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_796", + "entry": { + "target_id": "effect:effect_796", + "label": "effect_796", + "plain_source": "upright(\"to_extract\")(670) = upright(\"approx\")((sin((-(\"upright(\"lambda2\")\")))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * ((((\"1 / 6\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\"))) - (\"1 / 1\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 670 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_805", + "entry": { + "target_id": "effect:effect_805", + "label": "effect_805", + "plain_source": "upright(\"to_extract\")(678) = upright(\"approx\")((sin((-(\"upright(\"lambda2\")\")))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * (((((\"upright(\"lambda2\")\")^(\"2 / 1\")) * (((\"1 / 6\") + ((\" - 1 / 120\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\")))))) - (\"1 / 1\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 678 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 120\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_816", + "entry": { + "target_id": "effect:effect_816", + "label": "effect_816", + "plain_source": "upright(\"to_extract\")(688) = upright(\"approx\")((sin((-(\"upright(\"lambda2\")\")))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * (((((\"upright(\"lambda2\")\")^(\"2 / 1\")) * (((\"1 / 6\") + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * ((((\"1 / 5040\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\"))) - (\"1 / 120\"))))))) - (\"1 / 1\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 688 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 5040\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) $])) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_821", + "entry": { + "target_id": "effect:effect_821", + "label": "effect_821", + "plain_source": "upright(\"to_extract\")(692) = upright(\"approx\")(((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (\"upright(\"lambda2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 692 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_828", + "entry": { + "target_id": "effect:effect_828", + "label": "effect_828", + "plain_source": "upright(\"to_extract\")(698) = upright(\"approx\")(((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * ((((\" - 1 / 1\") * (\"upright(\"lambda1\")\")) + ((\"1 / 6\") * (((\"upright(\"lambda1\")\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\")))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 698 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_837", + "entry": { + "target_id": "effect:effect_837", + "label": "effect_837", + "plain_source": "upright(\"to_extract\")(706) = upright(\"approx\")(((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * ((((\" - 1 / 1\") * (\"upright(\"lambda1\")\")) + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * ((((\" - 1 / 120\") * (((\"upright(\"lambda1\")\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\"))))) + ((\"1 / 6\") * (\"upright(\"lambda1\")\")))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 706 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 120\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_848", + "entry": { + "target_id": "effect:effect_848", + "label": "effect_848", + "plain_source": "upright(\"to_extract\")(716) = upright(\"approx\")(((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * ((((\" - 1 / 1\") * (\"upright(\"lambda1\")\")) + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * ((((\"1 / 6\") * (\"upright(\"lambda1\")\")) + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * ((((\" - 1 / 120\") * (\"upright(\"lambda1\")\")) + ((\"1 / 5040\") * (((\"upright(\"lambda1\")\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\")))))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 716 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 120\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 5040\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $])) $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_851", + "entry": { + "target_id": "effect:effect_851", + "label": "effect_851", + "plain_source": "upright(\"to_extract\")(718) = upright(\"approx\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))))), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (\"upright(\"lambda2\")\")), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 718 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_857", + "entry": { + "target_id": "effect:effect_857", + "label": "effect_857", + "plain_source": "upright(\"to_extract\")(723) = upright(\"approx\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * (((\"upright(\"lambda1\")\") + ((\" - 1 / 6\") * (((\"upright(\"lambda1\")\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\")))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 723 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_866", + "entry": { + "target_id": "effect:effect_866", + "label": "effect_866", + "plain_source": "upright(\"to_extract\")(731) = upright(\"approx\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * (((\"upright(\"lambda1\")\") + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * ((((\" - 1 / 6\") * (\"upright(\"lambda1\")\")) + ((\"1 / 120\") * (((\"upright(\"lambda1\")\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\"))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 731 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_877", + "entry": { + "target_id": "effect:effect_877", + "label": "effect_877", + "plain_source": "upright(\"to_extract\")(741) = upright(\"approx\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * (((\"upright(\"lambda1\")\") + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * ((((\" - 1 / 6\") * (\"upright(\"lambda1\")\")) + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * ((((\" - 1 / 5040\") * (((\"upright(\"lambda1\")\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\"))))) + ((\"1 / 120\") * (\"upright(\"lambda1\")\"))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 741 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 5040\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_881", + "entry": { + "target_id": "effect:effect_881", + "label": "effect_881", + "plain_source": "upright(\"to_extract\")(744) = upright(\"approx\")(((cos((-(\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\")))))))), (upright(\"lower\")(((\"1 / 1\") + ((\"upright(\"lambda1\")\") * (\"upright(\"lambda2\")\"))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 744 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_888", + "entry": { + "target_id": "effect:effect_888", + "label": "effect_888", + "plain_source": "upright(\"to_extract\")(750) = upright(\"approx\")(((cos((-(\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\")))))))), (upright(\"lower\")(((\"1 / 1\") + ((\"upright(\"lambda2\")\") * (((\"upright(\"lambda1\")\") + ((\" - 1 / 2\") * (\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 750 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_897", + "entry": { + "target_id": "effect:effect_897", + "label": "effect_897", + "plain_source": "upright(\"to_extract\")(758) = upright(\"approx\")(((cos((-(\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\")))))))), (upright(\"lower\")(((\"1 / 1\") + ((\"upright(\"lambda2\")\") * (((\"upright(\"lambda1\")\") + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 6\") * (((\"upright(\"lambda1\")\") * (\"upright(\"lambda2\")\")))) - (\"1 / 2\")))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 758 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_903", + "entry": { + "target_id": "effect:effect_903", + "label": "effect_903", + "plain_source": "upright(\"to_extract\")(763) = upright(\"approx\")((sin(\"upright(\"lambda2\")\")), (upright(\"lower\")(((\"upright(\"lambda2\")\") * (((\"1 / 1\") + ((\" - 1 / 6\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 763 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_911", + "entry": { + "target_id": "effect:effect_911", + "label": "effect_911", + "plain_source": "upright(\"to_extract\")(770) = upright(\"approx\")((sin(\"upright(\"lambda2\")\")), (upright(\"lower\")(((\"upright(\"lambda2\")\") * (((\"1 / 1\") + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * ((((\"1 / 120\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\"))) - (\"1 / 6\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 770 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_921", + "entry": { + "target_id": "effect:effect_921", + "label": "effect_921", + "plain_source": "upright(\"to_extract\")(779) = upright(\"approx\")((sin(\"upright(\"lambda2\")\")), (upright(\"lower\")(((\"upright(\"lambda2\")\") * (((\"1 / 1\") + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * (((((\"upright(\"lambda2\")\")^(\"2 / 1\")) * (((\"1 / 120\") + ((\" - 1 / 5040\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\")))))) - (\"1 / 6\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 779 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 5040\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_924", + "entry": { + "target_id": "effect:effect_924", + "label": "effect_924", + "plain_source": "upright(\"to_extract\")(781) = upright(\"approx\")(((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * (sin(\"upright(\"lambda1\")\"))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 781 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_931", + "entry": { + "target_id": "effect:effect_931", + "label": "effect_931", + "plain_source": "upright(\"to_extract\")(787) = upright(\"approx\")(((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * (((sin(\"upright(\"lambda1\")\")) + ((\" - 1 / 6\") * ((((\"upright(\"lambda2\")\")^(\"2 / 1\")) * (sin(\"upright(\"lambda1\")\")))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 787 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_940", + "entry": { + "target_id": "effect:effect_940", + "label": "effect_940", + "plain_source": "upright(\"to_extract\")(795) = upright(\"approx\")(((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * (((sin(\"upright(\"lambda1\")\")) + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * ((((\" - 1 / 6\") * (sin(\"upright(\"lambda1\")\"))) + ((\"1 / 120\") * ((((\"upright(\"lambda2\")\")^(\"2 / 1\")) * (sin(\"upright(\"lambda1\")\"))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 795 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_951", + "entry": { + "target_id": "effect:effect_951", + "label": "effect_951", + "plain_source": "upright(\"to_extract\")(805) = upright(\"approx\")(((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * (((sin(\"upright(\"lambda1\")\")) + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * ((((\" - 1 / 6\") * (sin(\"upright(\"lambda1\")\"))) + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * ((((\" - 1 / 5040\") * ((((\"upright(\"lambda2\")\")^(\"2 / 1\")) * (sin(\"upright(\"lambda1\")\"))))) + ((\"1 / 120\") * (sin(\"upright(\"lambda1\")\")))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 805 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 5040\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_957", + "entry": { + "target_id": "effect:effect_957", + "label": "effect_957", + "plain_source": "upright(\"to_extract\")(810) = upright(\"approx\")((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))), (upright(\"lower\")(((cos(\"upright(\"lambda1\")\")) + ((\"upright(\"lambda2\")\") * (((sin(\"upright(\"lambda1\")\")) + ((\" - 1 / 2\") * (((\"upright(\"lambda2\")\") * (cos(\"upright(\"lambda1\")\"))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 810 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_963", + "entry": { + "target_id": "effect:effect_963", + "label": "effect_963", + "plain_source": "upright(\"to_extract\")(815) = upright(\"approx\")((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))), (upright(\"lower\")(((cos(\"upright(\"lambda1\")\")) + ((\"upright(\"lambda2\")\") * (((sin(\"upright(\"lambda1\")\")) + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (cos(\"upright(\"lambda1\")\"))) + ((\" - 1 / 6\") * (((\"upright(\"lambda2\")\") * (sin(\"upright(\"lambda1\")\")))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 815 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_967", + "entry": { + "target_id": "effect:effect_967", + "label": "effect_967", + "plain_source": "upright(\"to_extract\")(818) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")(((cos(\"upright(\"lambda1\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 818 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_974", + "entry": { + "target_id": "effect:effect_974", + "label": "effect_974", + "plain_source": "upright(\"to_extract\")(824) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")((((\"upright(\"lambda2\")\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\"))))))) + ((cos(\"upright(\"lambda1\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 824 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_982", + "entry": { + "target_id": "effect:effect_982", + "label": "effect_982", + "plain_source": "upright(\"to_extract\")(831) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")((((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (((\"upright(\"lambda2\")\") * (((cos(\"upright(\"lambda1\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))))))) + ((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\")))))))) + ((cos(\"upright(\"lambda1\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 831 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_992", + "entry": { + "target_id": "effect:effect_992", + "label": "effect_992", + "plain_source": "upright(\"to_extract\")(840) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")((((\"upright(\"lambda2\")\") * ((((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (((cos(\"upright(\"lambda1\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))))) + ((\" - 1 / 6\") * (((\"upright(\"lambda2\")\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\")))))))))))) + ((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\")))))))) + ((cos(\"upright(\"lambda1\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 840 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_996", + "entry": { + "target_id": "effect:effect_996", + "label": "effect_996", + "plain_source": "upright(\"to_extract\")(843) = upright(\"approx\")(((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), (upright(\"lower\")(((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"phi2\")\"))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 843 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1001", + "entry": { + "target_id": "effect:effect_1001", + "label": "effect_1001", + "plain_source": "upright(\"to_extract\")(847) = upright(\"approx\")(((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"lambda2\")\") * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\"))))) + ((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 847 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1009", + "entry": { + "target_id": "effect:effect_1009", + "label": "effect_1009", + "plain_source": "upright(\"to_extract\")(854) = upright(\"approx\")(((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (((\"upright(\"lambda2\")\") * (((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"phi2\")\"))))))) + ((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\")))))) + ((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 854 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1019", + "entry": { + "target_id": "effect:effect_1019", + "label": "effect_1019", + "plain_source": "upright(\"to_extract\")(863) = upright(\"approx\")(((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"lambda2\")\") * ((((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"phi2\")\"))))) + ((\" - 1 / 6\") * (((\"upright(\"lambda2\")\") * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\")))))))))) + ((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\")))))) + ((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 863 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1023", + "entry": { + "target_id": "effect:effect_1023", + "label": "effect_1023", + "plain_source": "upright(\"to_extract\")(866) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((cos(\"upright(\"lambda1\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 866 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1027", + "entry": { + "target_id": "effect:effect_1027", + "label": "effect_1027", + "plain_source": "upright(\"to_extract\")(869) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((\"upright(\"lambda2\")\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\"))))))) + ((((cos(\"upright(\"lambda1\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 869 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1031", + "entry": { + "target_id": "effect:effect_1031", + "label": "effect_1031", + "plain_source": "upright(\"to_extract\")(872) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (((\"upright(\"lambda2\")\") * (((cos(\"upright(\"lambda1\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))))))) + ((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\")))))))) + ((((cos(\"upright(\"lambda1\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 872 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1035", + "entry": { + "target_id": "effect:effect_1035", + "label": "effect_1035", + "plain_source": "upright(\"to_extract\")(875) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((\"upright(\"lambda2\")\") * ((((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (((cos(\"upright(\"lambda1\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))))) + ((\" - 1 / 6\") * (((\"upright(\"lambda2\")\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\")))))))))))) + ((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\")))))))) + ((((cos(\"upright(\"lambda1\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 875 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1039", + "entry": { + "target_id": "effect:effect_1039", + "label": "effect_1039", + "plain_source": "upright(\"to_extract\")(878) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos(\"upright(\"lambda1\")\")) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 878 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1044", + "entry": { + "target_id": "effect:effect_1044", + "label": "effect_1044", + "plain_source": "upright(\"to_extract\")(882) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos(\"upright(\"lambda1\")\")) + ((((\"upright(\"lambda2\")\") * (sin(\"upright(\"lambda1\")\"))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 882 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1049", + "entry": { + "target_id": "effect:effect_1049", + "label": "effect_1049", + "plain_source": "upright(\"to_extract\")(886) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos(\"upright(\"lambda1\")\")) + ((((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (((\"upright(\"lambda2\")\") * (cos(\"upright(\"lambda1\")\"))))) - ((\" - 1 / 1\") * (sin(\"upright(\"lambda1\")\")))))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 886 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1054", + "entry": { + "target_id": "effect:effect_1054", + "label": "effect_1054", + "plain_source": "upright(\"to_extract\")(890) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos(\"upright(\"lambda1\")\")) + ((((\"upright(\"lambda2\")\") * ((((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (cos(\"upright(\"lambda1\")\"))) + ((\" - 1 / 6\") * (((\"upright(\"lambda2\")\") * (sin(\"upright(\"lambda1\")\")))))))) - ((\" - 1 / 1\") * (sin(\"upright(\"lambda1\")\")))))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 890 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1058", + "entry": { + "target_id": "effect:effect_1058", + "label": "effect_1058", + "plain_source": "upright(\"to_extract\")(893) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 893 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1062", + "entry": { + "target_id": "effect:effect_1062", + "label": "effect_1062", + "plain_source": "upright(\"to_extract\")(896) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"lambda2\")\") * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\"))))) + ((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 896 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1066", + "entry": { + "target_id": "effect:effect_1066", + "label": "effect_1066", + "plain_source": "upright(\"to_extract\")(899) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (((\"upright(\"lambda2\")\") * (((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"phi2\")\"))))))) + ((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\")))))) + ((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 899 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1070", + "entry": { + "target_id": "effect:effect_1070", + "label": "effect_1070", + "plain_source": "upright(\"to_extract\")(902) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"lambda2\")\") * ((((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"phi2\")\"))))) + ((\" - 1 / 6\") * (((\"upright(\"lambda2\")\") * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\")))))))))) + ((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\")))))) + ((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 902 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1073", + "entry": { + "target_id": "effect:effect_1073", + "label": "effect_1073", + "plain_source": "upright(\"to_extract\")(904) = upright(\"approx\")((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")(((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 904 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1078", + "entry": { + "target_id": "effect:effect_1078", + "label": "effect_1078", + "plain_source": "upright(\"to_extract\")(908) = upright(\"approx\")((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")(((\"upright(\"lambda1\")\") + ((((\" - 1 / 1\") * (\"upright(\"lambda2\")\")) + ((\"1 / 2\") * (upright(\"pi\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 908 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1082", + "entry": { + "target_id": "effect:effect_1082", + "label": "effect_1082", + "plain_source": "upright(\"to_extract\")(911) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")), (upright(\"lower\")(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 911 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1086", + "entry": { + "target_id": "effect:effect_1086", + "label": "effect_1086", + "plain_source": "upright(\"to_extract\")(914) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")), (upright(\"lower\")(((((\"upright(\"lambda1\")\") + ((((\" - 1 / 1\") * (\"upright(\"lambda2\")\")) + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"phi2\")\")), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 914 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1090", + "entry": { + "target_id": "effect:effect_1090", + "label": "effect_1090", + "plain_source": "upright(\"to_extract\")(917) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 917 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1097", + "entry": { + "target_id": "effect:effect_1097", + "label": "effect_1097", + "plain_source": "upright(\"to_extract\")(923) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))) + ((\" - 1 / 1\") * (((\"upright(\"lambda2\")\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 923 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1106", + "entry": { + "target_id": "effect:effect_1106", + "label": "effect_1106", + "plain_source": "upright(\"to_extract\")(931) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))) + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))) + ((\" - 1 / 2\") * (((\"upright(\"lambda2\")\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 931 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1116", + "entry": { + "target_id": "effect:effect_1116", + "label": "effect_1116", + "plain_source": "upright(\"to_extract\")(940) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))) + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))) + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))) + ((\"1 / 6\") * (((\"upright(\"lambda2\")\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 940 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1119", + "entry": { + "target_id": "effect:effect_1119", + "label": "effect_1119", + "plain_source": "upright(\"to_extract\")(942) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")), (upright(\"lower\")(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 942 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1124", + "entry": { + "target_id": "effect:effect_1124", + "label": "effect_1124", + "plain_source": "upright(\"to_extract\")(946) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")), (upright(\"lower\")(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((((\" - 1 / 1\") * (\"upright(\"lambda2\")\")) + ((\"1 / 2\") * (upright(\"pi\")))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 946 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1128", + "entry": { + "target_id": "effect:effect_1128", + "label": "effect_1128", + "plain_source": "upright(\"to_extract\")(949) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 949 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1135", + "entry": { + "target_id": "effect:effect_1135", + "label": "effect_1135", + "plain_source": "upright(\"to_extract\")(955) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + ((\" - 1 / 1\") * (((\"upright(\"lambda2\")\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 955 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1144", + "entry": { + "target_id": "effect:effect_1144", + "label": "effect_1144", + "plain_source": "upright(\"to_extract\")(963) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 1\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\" - 1 / 2\") * (((\"upright(\"lambda2\")\") * (sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 963 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1154", + "entry": { + "target_id": "effect:effect_1154", + "label": "effect_1154", + "plain_source": "upright(\"to_extract\")(972) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 1\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\"1 / 6\") * (((\"upright(\"lambda2\")\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 972 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1158", + "entry": { + "target_id": "effect:effect_1158", + "label": "effect_1158", + "plain_source": "upright(\"to_extract\")(975) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")(((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 975 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1165", + "entry": { + "target_id": "effect:effect_1165", + "label": "effect_1165", + "plain_source": "upright(\"to_extract\")(981) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")(((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + (((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))) + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 1\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 981 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1175", + "entry": { + "target_id": "effect:effect_1175", + "label": "effect_1175", + "plain_source": "upright(\"to_extract\")(990) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")(((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + (((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))) + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 1\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))) + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\" - 1 / 2\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 990 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $]) $])) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1190", + "entry": { + "target_id": "effect:effect_1190", + "label": "effect_1190", + "plain_source": "upright(\"to_extract\")(1004) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")(((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + (((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))) + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 1\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))) + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((((\" - 1 / 2\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))) + ((\"upright(\"lambda2\")\") * ((((\"1 / 6\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\"1 / 6\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))))))))))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1004 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $]) $])) $])) $]) $])) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1194", + "entry": { + "target_id": "effect:effect_1194", + "label": "effect_1194", + "plain_source": "upright(\"to_extract\")(1007) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")(((\"1 / 2\") * (((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1007 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1199", + "entry": { + "target_id": "effect:effect_1199", + "label": "effect_1199", + "plain_source": "upright(\"to_extract\")(1011) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")((((\"1 / 2\") * (((\"upright(\"lambda2\")\") * ((((\" - 1 / 1\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))))) + ((\"1 / 2\") * (((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1011 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1207", + "entry": { + "target_id": "effect:effect_1207", + "label": "effect_1207", + "plain_source": "upright(\"to_extract\")(1018) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")((((\"1 / 2\") * (((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))))) + ((\"upright(\"lambda2\")\") * ((((\"1 / 2\") * (((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\" - 1 / 2\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))))) + ((\"1 / 2\") * ((((\" - 1 / 1\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1018 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1217", + "entry": { + "target_id": "effect:effect_1217", + "label": "effect_1217", + "plain_source": "upright(\"to_extract\")(1027) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")((((\"1 / 2\") * (((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))))) + ((\"upright(\"lambda2\")\") * ((((\"1 / 2\") * ((((\" - 1 / 1\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))) + ((\"upright(\"lambda2\")\") * ((((\"1 / 2\") * (((\"upright(\"lambda2\")\") * ((((\"1 / 6\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\"1 / 6\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))))) + ((\"1 / 2\") * ((((\" - 1 / 2\") * (sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\" - 1 / 2\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1027 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1221", + "entry": { + "target_id": "effect:effect_1221", + "label": "effect_1221", + "plain_source": "upright(\"to_extract\")(1030) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")((((\"1 / 2\") * (((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))))) + ((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1030 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1225", + "entry": { + "target_id": "effect:effect_1225", + "label": "effect_1225", + "plain_source": "upright(\"to_extract\")(1033) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")((((\"1 / 2\") * (((\"upright(\"lambda2\")\") * ((((\" - 1 / 1\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))))) + ((((\"1 / 2\") * (((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))))) + ((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1033 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1230", + "entry": { + "target_id": "effect:effect_1230", + "label": "effect_1230", + "plain_source": "upright(\"to_extract\")(1037) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")((((\"1 / 2\") * (((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))))) + ((((\"upright(\"lambda2\")\") * ((((\"1 / 2\") * (((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\" - 1 / 2\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))))) + ((\"1 / 2\") * ((((\" - 1 / 1\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))))))))) + ((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1037 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1235", + "entry": { + "target_id": "effect:effect_1235", + "label": "effect_1235", + "plain_source": "upright(\"to_extract\")(1041) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")((((\"1 / 2\") * (((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))))) + ((((\"upright(\"lambda2\")\") * ((((\"1 / 2\") * ((((\" - 1 / 1\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))) + ((\"upright(\"lambda2\")\") * ((((\"1 / 2\") * (((\"upright(\"lambda2\")\") * ((((\"1 / 6\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\"1 / 6\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))))) + ((\"1 / 2\") * ((((\" - 1 / 2\") * (sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\" - 1 / 2\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))))))))) + ((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1041 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1241", + "entry": { + "target_id": "effect:effect_1241", + "label": "effect_1241", + "plain_source": "upright(\"to_extract\")(1046) = upright(\"approx\")(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")), (upright(\"lower\")(((\"upright(\"lambda2\")\") * (((frac(\"upright(\"lambda1\")\", \"upright(\"lambda2\")\")) - (\"1 / 1\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1046 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1244", + "entry": { + "target_id": "effect:effect_1244", + "label": "effect_1244", + "plain_source": "upright(\"to_extract\")(1048) = upright(\"approx\")((sin((-(\"upright(\"lambda2\")\")))), (upright(\"lower\")((sin((-(\"upright(\"lambda2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1048 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1247", + "entry": { + "target_id": "effect:effect_1247", + "label": "effect_1247", + "plain_source": "upright(\"to_extract\")(1050) = upright(\"approx\")((sin(\"upright(\"lambda2\")\")), (upright(\"lower\")((sin(\"upright(\"lambda2\")\")), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1050 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1255", + "entry": { + "target_id": "effect:effect_1255", + "label": "effect_1255", + "plain_source": "upright(\"to_extract\")(1057) = upright(\"approx\")((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * ((((((\"1 / 2\") * ((frac(upright(\"pi\"), \"upright(\"lambda2\")\")))) + (frac(\"upright(\"lambda1\")\", \"upright(\"lambda2\")\")))) - (\"1 / 1\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1057 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1262", + "entry": { + "target_id": "effect:effect_1262", + "label": "effect_1262", + "plain_source": "upright(\"to_extract\")(1063) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")), (upright(\"lower\")(((\"upright(\"lambda2\")\") * ((((((\"1 / 2\") * ((frac(upright(\"pi\"), \"upright(\"lambda2\")\")))) + (frac(\"upright(\"lambda1\")\", \"upright(\"lambda2\")\")))) - (((\"1 / 1\") + (frac(\"upright(\"phi2\")\", \"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1063 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1269", + "entry": { + "target_id": "effect:effect_1269", + "label": "effect_1269", + "plain_source": "upright(\"to_extract\")(1069) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")), (upright(\"lower\")(((\"upright(\"lambda2\")\") * ((((((\"1 / 2\") * ((frac(upright(\"pi\"), \"upright(\"lambda2\")\")))) + (((frac(\"upright(\"lambda1\")\", \"upright(\"lambda2\")\")) + (frac(\"upright(\"phi2\")\", \"upright(\"lambda2\")\")))))) - (\"1 / 1\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1069 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1276", + "entry": { + "target_id": "effect:effect_1276", + "label": "effect_1276", + "plain_source": "upright(\"to_extract\")(1075) = upright(\"approx\")(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"lambda2\")\") * (((\"1 / 1\") + ((\" - 1 / 1\") * ((frac(\"upright(\"lambda1\")\", \"upright(\"lambda2\")\"))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1075 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1280", + "entry": { + "target_id": "effect:effect_1280", + "label": "effect_1280", + "plain_source": "upright(\"to_extract\")(1078) = upright(\"approx\")((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")((cos(((\"upright(\"lambda1\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda2\")\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1078 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1284", + "entry": { + "target_id": "effect:effect_1284", + "label": "effect_1284", + "plain_source": "upright(\"to_extract\")(1081) = upright(\"approx\")((cos((-(\"upright(\"lambda2\")\")))), (upright(\"lower\")((cos(((\" - 1 / 1\") * (\"upright(\"lambda2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1081 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1288", + "entry": { + "target_id": "effect:effect_1288", + "label": "effect_1288", + "plain_source": "upright(\"to_extract\")(1084) = upright(\"approx\")((sin((-(\"upright(\"lambda2\")\")))), (upright(\"lower\")((sin(((\" - 1 / 1\") * (\"upright(\"lambda2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1084 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1292", + "entry": { + "target_id": "effect:effect_1292", + "label": "effect_1292", + "plain_source": "upright(\"to_extract\")(1087) = upright(\"approx\")(((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (sin(((\" - 1 / 1\") * (\"upright(\"lambda2\")\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1087 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1296", + "entry": { + "target_id": "effect:effect_1296", + "label": "effect_1296", + "plain_source": "upright(\"to_extract\")(1090) = upright(\"approx\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))))), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin(((\" - 1 / 1\") * (\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1090 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1300", + "entry": { + "target_id": "effect:effect_1300", + "label": "effect_1300", + "plain_source": "upright(\"to_extract\")(1093) = upright(\"approx\")(((cos((-(\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\")))))))), (upright(\"lower\")(((cos(((\" - 1 / 1\") * (\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin(((\" - 1 / 1\") * (\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1093 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1305", + "entry": { + "target_id": "effect:effect_1305", + "label": "effect_1305", + "plain_source": "upright(\"to_extract\")(1097) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")(((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1097 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1309", + "entry": { + "target_id": "effect:effect_1309", + "label": "effect_1309", + "plain_source": "upright(\"to_extract\")(1100) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos(((\"upright(\"lambda1\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda2\")\"))))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1100 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1313", + "entry": { + "target_id": "effect:effect_1313", + "label": "effect_1313", + "plain_source": "upright(\"to_extract\")(1103) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1103 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1321", + "entry": { + "target_id": "effect:effect_1321", + "label": "effect_1321", + "plain_source": "upright(\"to_extract\")(1110) = upright(\"approx\")((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"lambda2\")\") * (((\"1 / 1\") + ((\" - 1 / 1\") * ((frac(((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\")))), \"upright(\"lambda2\")\"))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1110 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1329", + "entry": { + "target_id": "effect:effect_1329", + "label": "effect_1329", + "plain_source": "upright(\"to_extract\")(1117) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"lambda2\")\") * (((\"1 / 1\") + ((\" - 1 / 1\") * ((frac(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")), \"upright(\"lambda2\")\"))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1117 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1333", + "entry": { + "target_id": "effect:effect_1333", + "label": "effect_1333", + "plain_source": "upright(\"to_extract\")(1120) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")((sin(((((\"upright(\"lambda1\")\") + ((((\" - 1 / 1\") * (\"upright(\"lambda2\")\")) + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"phi2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1120 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1341", + "entry": { + "target_id": "effect:effect_1341", + "label": "effect_1341", + "plain_source": "upright(\"to_extract\")(1127) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"lambda2\")\") * (((\"1 / 1\") + ((\" - 1 / 1\") * ((frac(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))), \"upright(\"lambda2\")\"))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1127 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1345", + "entry": { + "target_id": "effect:effect_1345", + "label": "effect_1345", + "plain_source": "upright(\"to_extract\")(1130) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((((\" - 1 / 1\") * (\"upright(\"lambda2\")\")) + ((\"1 / 2\") * (upright(\"pi\")))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1130 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1349", + "entry": { + "target_id": "effect:effect_1349", + "label": "effect_1349", + "plain_source": "upright(\"to_extract\")(1133) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")(((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((((\" - 1 / 1\") * (\"upright(\"lambda2\")\")) + ((\"1 / 2\") * (upright(\"pi\")))))))))) + (sin(((((\"upright(\"lambda1\")\") + ((((\" - 1 / 1\") * (\"upright(\"lambda2\")\")) + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"phi2\")\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1133 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1353", + "entry": { + "target_id": "effect:effect_1353", + "label": "effect_1353", + "plain_source": "upright(\"to_extract\")(1136) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")(((\"1 / 2\") * (((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((((\" - 1 / 1\") * (\"upright(\"lambda2\")\")) + ((\"1 / 2\") * (upright(\"pi\")))))))))) + (sin(((((\"upright(\"lambda1\")\") + ((((\" - 1 / 1\") * (\"upright(\"lambda2\")\")) + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"phi2\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1136 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1357", + "entry": { + "target_id": "effect:effect_1357", + "label": "effect_1357", + "plain_source": "upright(\"to_extract\")(1139) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")((((\"1 / 2\") * (((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((((\" - 1 / 1\") * (\"upright(\"lambda2\")\")) + ((\"1 / 2\") * (upright(\"pi\")))))))))) + (sin(((((\"upright(\"lambda1\")\") + ((((\" - 1 / 1\") * (\"upright(\"lambda2\")\")) + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"phi2\")\"))))))) + ((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1139 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1361", + "entry": { + "target_id": "effect:effect_1361", + "label": "effect_1361", + "plain_source": "upright(\"to_extract\")(1142) = upright(\"approx\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1142 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1365", + "entry": { + "target_id": "effect:effect_1365", + "label": "effect_1365", + "plain_source": "upright(\"to_extract\")(1145) = upright(\"approx\")((upright(\"acos\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))))), (upright(\"lower\")((upright(\"acos\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1145 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1369", + "entry": { + "target_id": "effect:effect_1369", + "label": "effect_1369", + "plain_source": "upright(\"to_extract\")(1148) = upright(\"approx\")(((upright(\"acos\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))))) * (\"R\")), (upright(\"lower\")(((\"R\") * (upright(\"acos\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1148 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"R\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"R\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1372", + "entry": { + "target_id": "effect:effect_1372", + "label": "effect_1372", + "plain_source": "upright(\"to_extract\")(1150) = upright(\"approx\")(\"upright(\"phi1\")\", (upright(\"lower\")(\"upright(\"phi1\")\", \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1150 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1379", + "entry": { + "target_id": "effect:effect_1379", + "label": "effect_1379", + "plain_source": "upright(\"to_extract\")(1156) = upright(\"approx\")((sin(\"upright(\"phi1\")\")), (upright(\"lower\")(((\"upright(\"phi1\")\") * (((\"1 / 1\") + ((\" - 1 / 6\") * ((\"upright(\"phi1\")\")^(\"2 / 1\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1156 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1387", + "entry": { + "target_id": "effect:effect_1387", + "label": "effect_1387", + "plain_source": "upright(\"to_extract\")(1163) = upright(\"approx\")((sin(\"upright(\"phi1\")\")), (upright(\"lower\")(((\"upright(\"phi1\")\") * (((\"1 / 1\") + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\"1 / 120\") * ((\"upright(\"phi1\")\")^(\"2 / 1\"))) - (\"1 / 6\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1163 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1397", + "entry": { + "target_id": "effect:effect_1397", + "label": "effect_1397", + "plain_source": "upright(\"to_extract\")(1172) = upright(\"approx\")((sin(\"upright(\"phi1\")\")), (upright(\"lower\")(((\"upright(\"phi1\")\") * (((\"1 / 1\") + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * (((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (((\"1 / 120\") + ((\" - 1 / 5040\") * ((\"upright(\"phi1\")\")^(\"2 / 1\")))))) - (\"1 / 6\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1172 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 5040\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1400", + "entry": { + "target_id": "effect:effect_1400", + "label": "effect_1400", + "plain_source": "upright(\"to_extract\")(1174) = upright(\"approx\")(((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))), (upright(\"lower\")(((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1174 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1407", + "entry": { + "target_id": "effect:effect_1407", + "label": "effect_1407", + "plain_source": "upright(\"to_extract\")(1180) = upright(\"approx\")(((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))), (upright(\"lower\")(((\"upright(\"phi1\")\") * (((sin(\"upright(\"phi2\")\")) + ((\" - 1 / 6\") * ((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (sin(\"upright(\"phi2\")\")))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1180 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1416", + "entry": { + "target_id": "effect:effect_1416", + "label": "effect_1416", + "plain_source": "upright(\"to_extract\")(1188) = upright(\"approx\")(((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))), (upright(\"lower\")(((\"upright(\"phi1\")\") * (((sin(\"upright(\"phi2\")\")) + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\" - 1 / 6\") * (sin(\"upright(\"phi2\")\"))) + ((\"1 / 120\") * ((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (sin(\"upright(\"phi2\")\"))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1188 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1427", + "entry": { + "target_id": "effect:effect_1427", + "label": "effect_1427", + "plain_source": "upright(\"to_extract\")(1198) = upright(\"approx\")(((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))), (upright(\"lower\")(((\"upright(\"phi1\")\") * (((sin(\"upright(\"phi2\")\")) + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\" - 1 / 6\") * (sin(\"upright(\"phi2\")\"))) + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\" - 1 / 5040\") * ((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (sin(\"upright(\"phi2\")\"))))) + ((\"1 / 120\") * (sin(\"upright(\"phi2\")\")))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1198 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 5040\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1432", + "entry": { + "target_id": "effect:effect_1432", + "label": "effect_1432", + "plain_source": "upright(\"to_extract\")(1202) = upright(\"approx\")((cos(\"upright(\"phi1\")\")), (upright(\"lower\")(((\"1 / 1\") + ((\" - 1 / 2\") * ((\"upright(\"phi1\")\")^(\"2 / 1\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1202 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1439", + "entry": { + "target_id": "effect:effect_1439", + "label": "effect_1439", + "plain_source": "upright(\"to_extract\")(1208) = upright(\"approx\")((cos(\"upright(\"phi1\")\")), (upright(\"lower\")(((\"1 / 1\") + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\"1 / 24\") * ((\"upright(\"phi1\")\")^(\"2 / 1\"))) - (\"1 / 2\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1208 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1448", + "entry": { + "target_id": "effect:effect_1448", + "label": "effect_1448", + "plain_source": "upright(\"to_extract\")(1216) = upright(\"approx\")((cos(\"upright(\"phi1\")\")), (upright(\"lower\")(((\"1 / 1\") + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * (((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (((\"1 / 24\") + ((\" - 1 / 720\") * ((\"upright(\"phi1\")\")^(\"2 / 1\")))))) - (\"1 / 2\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1216 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 720\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1451", + "entry": { + "target_id": "effect:effect_1451", + "label": "effect_1451", + "plain_source": "upright(\"to_extract\")(1218) = upright(\"approx\")(((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))), (upright(\"lower\")((cos(\"upright(\"phi2\")\")), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1218 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1457", + "entry": { + "target_id": "effect:effect_1457", + "label": "effect_1457", + "plain_source": "upright(\"to_extract\")(1223) = upright(\"approx\")(((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos(\"upright(\"phi2\")\")) + ((\" - 1 / 2\") * ((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (cos(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1223 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1465", + "entry": { + "target_id": "effect:effect_1465", + "label": "effect_1465", + "plain_source": "upright(\"to_extract\")(1230) = upright(\"approx\")(((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos(\"upright(\"phi2\")\")) + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\" - 1 / 2\") * (cos(\"upright(\"phi2\")\"))) + ((\"1 / 24\") * ((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (cos(\"upright(\"phi2\")\"))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1230 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1475", + "entry": { + "target_id": "effect:effect_1475", + "label": "effect_1475", + "plain_source": "upright(\"to_extract\")(1239) = upright(\"approx\")(((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos(\"upright(\"phi2\")\")) + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\" - 1 / 2\") * (cos(\"upright(\"phi2\")\"))) + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\" - 1 / 720\") * ((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (cos(\"upright(\"phi2\")\"))))) + ((\"1 / 24\") * (cos(\"upright(\"phi2\")\")))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1239 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 720\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1479", + "entry": { + "target_id": "effect:effect_1479", + "label": "effect_1479", + "plain_source": "upright(\"to_extract\")(1242) = upright(\"approx\")(((\"upright(\"phi2\")\") * (sin(\"upright(\"phi1\")\"))), (upright(\"lower\")(((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\")), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1242 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1486", + "entry": { + "target_id": "effect:effect_1486", + "label": "effect_1486", + "plain_source": "upright(\"to_extract\")(1248) = upright(\"approx\")(((\"upright(\"phi2\")\") * (sin(\"upright(\"phi1\")\"))), (upright(\"lower\")(((\"upright(\"phi1\")\") * (((\"upright(\"phi2\")\") + ((\" - 1 / 6\") * ((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (\"upright(\"phi2\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1248 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1495", + "entry": { + "target_id": "effect:effect_1495", + "label": "effect_1495", + "plain_source": "upright(\"to_extract\")(1256) = upright(\"approx\")(((\"upright(\"phi2\")\") * (sin(\"upright(\"phi1\")\"))), (upright(\"lower\")(((\"upright(\"phi1\")\") * (((\"upright(\"phi2\")\") + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\" - 1 / 6\") * (\"upright(\"phi2\")\")) + ((\"1 / 120\") * ((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (\"upright(\"phi2\")\")))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1256 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1506", + "entry": { + "target_id": "effect:effect_1506", + "label": "effect_1506", + "plain_source": "upright(\"to_extract\")(1266) = upright(\"approx\")(((\"upright(\"phi2\")\") * (sin(\"upright(\"phi1\")\"))), (upright(\"lower\")(((\"upright(\"phi1\")\") * (((\"upright(\"phi2\")\") + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\" - 1 / 6\") * (\"upright(\"phi2\")\")) + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\" - 1 / 5040\") * ((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (\"upright(\"phi2\")\")))) + ((\"1 / 120\") * (\"upright(\"phi2\")\"))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1266 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 5040\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1509", + "entry": { + "target_id": "effect:effect_1509", + "label": "effect_1509", + "plain_source": "upright(\"to_extract\")(1268) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")(((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1268 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1515", + "entry": { + "target_id": "effect:effect_1515", + "label": "effect_1515", + "plain_source": "upright(\"to_extract\")(1273) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")((((\" - 1 / 2\") * ((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1273 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1523", + "entry": { + "target_id": "effect:effect_1523", + "label": "effect_1523", + "plain_source": "upright(\"to_extract\")(1280) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")((((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\" - 1 / 2\") * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))) + ((\"1 / 24\") * ((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1280 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1533", + "entry": { + "target_id": "effect:effect_1533", + "label": "effect_1533", + "plain_source": "upright(\"to_extract\")(1289) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")((((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\" - 1 / 2\") * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))) + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\" - 1 / 720\") * ((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))))) + ((\"1 / 24\") * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1289 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 720\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1537", + "entry": { + "target_id": "effect:effect_1537", + "label": "effect_1537", + "plain_source": "upright(\"to_extract\")(1292) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1292 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1545", + "entry": { + "target_id": "effect:effect_1545", + "label": "effect_1545", + "plain_source": "upright(\"to_extract\")(1299) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((\"upright(\"phi1\")\") * (((sin(\"upright(\"phi2\")\")) + ((\" - 1 / 2\") * (((\"upright(\"phi1\")\") * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))))))))))))) + ((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1299 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1555", + "entry": { + "target_id": "effect:effect_1555", + "label": "effect_1555", + "plain_source": "upright(\"to_extract\")(1308) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((\"upright(\"phi1\")\") * (((sin(\"upright(\"phi2\")\")) + ((\"upright(\"phi1\")\") * ((((\" - 1 / 2\") * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((\" - 1 / 6\") * (((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))))))))))) + ((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1308 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1563", + "entry": { + "target_id": "effect:effect_1563", + "label": "effect_1563", + "plain_source": "upright(\"to_extract\")(1315) = upright(\"approx\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"phi1\")\") * (((sin(\"upright(\"phi2\")\")) + ((\" - 1 / 2\") * (((\"upright(\"phi1\")\") * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))))))))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1315 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1571", + "entry": { + "target_id": "effect:effect_1571", + "label": "effect_1571", + "plain_source": "upright(\"to_extract\")(1322) = upright(\"approx\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"phi1\")\") * (((sin(\"upright(\"phi2\")\")) + ((\"upright(\"phi1\")\") * ((((\" - 1 / 2\") * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))) + ((\" - 1 / 6\") * (((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))))))))))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1322 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1574", + "entry": { + "target_id": "effect:effect_1574", + "label": "effect_1574", + "plain_source": "upright(\"to_extract\")(1324) = upright(\"approx\")((sin(\"upright(\"phi1\")\")), (upright(\"lower\")((sin(\"upright(\"phi1\")\")), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1324 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1577", + "entry": { + "target_id": "effect:effect_1577", + "label": "effect_1577", + "plain_source": "upright(\"to_extract\")(1326) = upright(\"approx\")(((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))), (upright(\"lower\")(((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1326 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1580", + "entry": { + "target_id": "effect:effect_1580", + "label": "effect_1580", + "plain_source": "upright(\"to_extract\")(1328) = upright(\"approx\")((cos(\"upright(\"phi1\")\")), (upright(\"lower\")((cos(\"upright(\"phi1\")\")), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1328 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1583", + "entry": { + "target_id": "effect:effect_1583", + "label": "effect_1583", + "plain_source": "upright(\"to_extract\")(1330) = upright(\"approx\")(((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1330 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1586", + "entry": { + "target_id": "effect:effect_1586", + "label": "effect_1586", + "plain_source": "upright(\"to_extract\")(1332) = upright(\"approx\")(((\"upright(\"phi2\")\") * (sin(\"upright(\"phi1\")\"))), (upright(\"lower\")(((\"upright(\"phi2\")\") * (sin(\"upright(\"phi1\")\"))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1332 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1592", + "entry": { + "target_id": "effect:effect_1592", + "label": "effect_1592", + "plain_source": "upright(\"to_extract\")(1337) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((\"upright(\"phi1\")\") * (((\"upright(\"phi2\")\") + (frac(cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))), \"upright(\"phi1\")\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1337 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1598", + "entry": { + "target_id": "effect:effect_1598", + "label": "effect_1598", + "plain_source": "upright(\"to_extract\")(1342) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")(((\"upright(\"phi1\")\") * (((sin(\"upright(\"phi2\")\")) + (frac(((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), \"upright(\"phi1\")\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1342 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1605", + "entry": { + "target_id": "effect:effect_1605", + "label": "effect_1605", + "plain_source": "upright(\"to_extract\")(1348) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")(((\"upright(\"phi1\")\") * (((sin(\"upright(\"phi2\")\")) + ((\"1 / 2\") * ((frac(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"lambda2\")\"))))), \"upright(\"phi1\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1348 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1613", + "entry": { + "target_id": "effect:effect_1613", + "label": "effect_1613", + "plain_source": "upright(\"to_extract\")(1355) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"phi1\")\") * ((((\" - 1 / 1\") * (\"upright(\"phi2\")\")) + ((\" - 1 / 1\") * ((frac(cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))), \"upright(\"phi1\")\"))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1355 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $])) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1621", + "entry": { + "target_id": "effect:effect_1621", + "label": "effect_1621", + "plain_source": "upright(\"to_extract\")(1362) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"phi1\")\") * ((((\" - 1 / 1\") * (sin(\"upright(\"phi2\")\"))) + ((\" - 1 / 1\") * ((frac(((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), \"upright(\"phi1\")\"))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1362 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $])) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1628", + "entry": { + "target_id": "effect:effect_1628", + "label": "effect_1628", + "plain_source": "upright(\"to_extract\")(1368) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"phi1\")\") * ((((\" - 1 / 1\") * (sin(\"upright(\"phi2\")\"))) + ((\" - 1 / 2\") * ((frac(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"lambda2\")\"))))), \"upright(\"phi1\")\"))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1368 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $])) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1631", + "entry": { + "target_id": "effect:effect_1631", + "label": "effect_1631", + "plain_source": "upright(\"to_extract\")(1370) = upright(\"approx\")(\"upright(\"phi2\")\", (upright(\"lower\")(\"upright(\"phi2\")\", \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1370 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1638", + "entry": { + "target_id": "effect:effect_1638", + "label": "effect_1638", + "plain_source": "upright(\"to_extract\")(1376) = upright(\"approx\")((sin(\"upright(\"phi2\")\")), (upright(\"lower\")(((\"upright(\"phi2\")\") * (((\"1 / 1\") + ((\" - 1 / 6\") * ((\"upright(\"phi2\")\")^(\"2 / 1\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1376 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1646", + "entry": { + "target_id": "effect:effect_1646", + "label": "effect_1646", + "plain_source": "upright(\"to_extract\")(1383) = upright(\"approx\")((sin(\"upright(\"phi2\")\")), (upright(\"lower\")(((\"upright(\"phi2\")\") * (((\"1 / 1\") + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\"1 / 120\") * ((\"upright(\"phi2\")\")^(\"2 / 1\"))) - (\"1 / 6\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1383 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1656", + "entry": { + "target_id": "effect:effect_1656", + "label": "effect_1656", + "plain_source": "upright(\"to_extract\")(1392) = upright(\"approx\")((sin(\"upright(\"phi2\")\")), (upright(\"lower\")(((\"upright(\"phi2\")\") * (((\"1 / 1\") + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * (((((\"upright(\"phi2\")\")^(\"2 / 1\")) * (((\"1 / 120\") + ((\" - 1 / 5040\") * ((\"upright(\"phi2\")\")^(\"2 / 1\")))))) - (\"1 / 6\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1392 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 5040\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1663", + "entry": { + "target_id": "effect:effect_1663", + "label": "effect_1663", + "plain_source": "upright(\"to_extract\")(1398) = upright(\"approx\")(((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))), (upright(\"lower\")(((\"upright(\"phi2\")\") * (((sin(\"upright(\"phi1\")\")) + ((\" - 1 / 6\") * ((((\"upright(\"phi2\")\")^(\"2 / 1\")) * (sin(\"upright(\"phi1\")\")))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1398 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1672", + "entry": { + "target_id": "effect:effect_1672", + "label": "effect_1672", + "plain_source": "upright(\"to_extract\")(1406) = upright(\"approx\")(((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))), (upright(\"lower\")(((\"upright(\"phi2\")\") * (((sin(\"upright(\"phi1\")\")) + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\" - 1 / 6\") * (sin(\"upright(\"phi1\")\"))) + ((\"1 / 120\") * ((((\"upright(\"phi2\")\")^(\"2 / 1\")) * (sin(\"upright(\"phi1\")\"))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1406 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1683", + "entry": { + "target_id": "effect:effect_1683", + "label": "effect_1683", + "plain_source": "upright(\"to_extract\")(1416) = upright(\"approx\")(((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))), (upright(\"lower\")(((\"upright(\"phi2\")\") * (((sin(\"upright(\"phi1\")\")) + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\" - 1 / 6\") * (sin(\"upright(\"phi1\")\"))) + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\" - 1 / 5040\") * ((((\"upright(\"phi2\")\")^(\"2 / 1\")) * (sin(\"upright(\"phi1\")\"))))) + ((\"1 / 120\") * (sin(\"upright(\"phi1\")\")))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1416 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 5040\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1688", + "entry": { + "target_id": "effect:effect_1688", + "label": "effect_1688", + "plain_source": "upright(\"to_extract\")(1420) = upright(\"approx\")((cos(\"upright(\"phi2\")\")), (upright(\"lower\")(((\"1 / 1\") + ((\" - 1 / 2\") * ((\"upright(\"phi2\")\")^(\"2 / 1\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1420 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1695", + "entry": { + "target_id": "effect:effect_1695", + "label": "effect_1695", + "plain_source": "upright(\"to_extract\")(1426) = upright(\"approx\")((cos(\"upright(\"phi2\")\")), (upright(\"lower\")(((\"1 / 1\") + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\"1 / 24\") * ((\"upright(\"phi2\")\")^(\"2 / 1\"))) - (\"1 / 2\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1426 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1704", + "entry": { + "target_id": "effect:effect_1704", + "label": "effect_1704", + "plain_source": "upright(\"to_extract\")(1434) = upright(\"approx\")((cos(\"upright(\"phi2\")\")), (upright(\"lower\")(((\"1 / 1\") + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * (((((\"upright(\"phi2\")\")^(\"2 / 1\")) * (((\"1 / 24\") + ((\" - 1 / 720\") * ((\"upright(\"phi2\")\")^(\"2 / 1\")))))) - (\"1 / 2\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1434 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 720\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1710", + "entry": { + "target_id": "effect:effect_1710", + "label": "effect_1710", + "plain_source": "upright(\"to_extract\")(1439) = upright(\"approx\")(((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos(\"upright(\"phi1\")\")) + ((\" - 1 / 2\") * ((((\"upright(\"phi2\")\")^(\"2 / 1\")) * (cos(\"upright(\"phi1\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1439 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1718", + "entry": { + "target_id": "effect:effect_1718", + "label": "effect_1718", + "plain_source": "upright(\"to_extract\")(1446) = upright(\"approx\")(((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos(\"upright(\"phi1\")\")) + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\" - 1 / 2\") * (cos(\"upright(\"phi1\")\"))) + ((\"1 / 24\") * ((((\"upright(\"phi2\")\")^(\"2 / 1\")) * (cos(\"upright(\"phi1\")\"))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1446 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1728", + "entry": { + "target_id": "effect:effect_1728", + "label": "effect_1728", + "plain_source": "upright(\"to_extract\")(1455) = upright(\"approx\")(((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos(\"upright(\"phi1\")\")) + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\" - 1 / 2\") * (cos(\"upright(\"phi1\")\"))) + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\" - 1 / 720\") * ((((\"upright(\"phi2\")\")^(\"2 / 1\")) * (cos(\"upright(\"phi1\")\"))))) + ((\"1 / 24\") * (cos(\"upright(\"phi1\")\")))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1455 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 720\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1731", + "entry": { + "target_id": "effect:effect_1731", + "label": "effect_1731", + "plain_source": "upright(\"to_extract\")(1457) = upright(\"approx\")(((\"upright(\"phi2\")\")^(\"2 / 1\")), (upright(\"lower\")(((\"upright(\"phi2\")\")^(\"2 / 1\")), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1457 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1734", + "entry": { + "target_id": "effect:effect_1734", + "label": "effect_1734", + "plain_source": "upright(\"to_extract\")(1459) = upright(\"approx\")(((\" - 1 / 2\") * ((\"upright(\"phi2\")\")^(\"2 / 1\"))), (upright(\"lower\")(((\" - 1 / 2\") * ((\"upright(\"phi2\")\")^(\"2 / 1\"))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1459 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1738", + "entry": { + "target_id": "effect:effect_1738", + "label": "effect_1738", + "plain_source": "upright(\"to_extract\")(1462) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")(((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1462 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1744", + "entry": { + "target_id": "effect:effect_1744", + "label": "effect_1744", + "plain_source": "upright(\"to_extract\")(1467) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")((((\" - 1 / 2\") * ((((\"upright(\"phi2\")\")^(\"2 / 1\")) * (((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))))) + ((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1467 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1752", + "entry": { + "target_id": "effect:effect_1752", + "label": "effect_1752", + "plain_source": "upright(\"to_extract\")(1474) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")((((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\" - 1 / 2\") * (((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))) + ((\"1 / 24\") * ((((\"upright(\"phi2\")\")^(\"2 / 1\")) * (((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1474 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1762", + "entry": { + "target_id": "effect:effect_1762", + "label": "effect_1762", + "plain_source": "upright(\"to_extract\")(1483) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")((((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\" - 1 / 2\") * (((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))) + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\" - 1 / 720\") * ((((\"upright(\"phi2\")\")^(\"2 / 1\")) * (((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))))) + ((\"1 / 24\") * (((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1483 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 720\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1768", + "entry": { + "target_id": "effect:effect_1768", + "label": "effect_1768", + "plain_source": "upright(\"to_extract\")(1488) = upright(\"approx\")(((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\" - 1 / 2\") * ((((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1488 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1777", + "entry": { + "target_id": "effect:effect_1777", + "label": "effect_1777", + "plain_source": "upright(\"to_extract\")(1496) = upright(\"approx\")(((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))) + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\" - 1 / 2\") * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))) + ((\"1 / 24\") * ((((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1496 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1788", + "entry": { + "target_id": "effect:effect_1788", + "label": "effect_1788", + "plain_source": "upright(\"to_extract\")(1506) = upright(\"approx\")(((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))) + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\" - 1 / 2\") * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))) + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\" - 1 / 720\") * ((((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((\"1 / 24\") * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))))))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1506 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 720\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1792", + "entry": { + "target_id": "effect:effect_1792", + "label": "effect_1792", + "plain_source": "upright(\"to_extract\")(1509) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")(((cos(\"upright(\"phi1\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1509 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1796", + "entry": { + "target_id": "effect:effect_1796", + "label": "effect_1796", + "plain_source": "upright(\"to_extract\")(1512) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((\"upright(\"phi2\")\") * (sin(\"upright(\"phi1\")\"))) + ((cos(\"upright(\"phi1\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1512 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1804", + "entry": { + "target_id": "effect:effect_1804", + "label": "effect_1804", + "plain_source": "upright(\"to_extract\")(1519) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((\"upright(\"phi2\")\") * (((sin(\"upright(\"phi1\")\")) + ((\" - 1 / 2\") * (((\"upright(\"phi2\")\") * (((cos(\"upright(\"phi1\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))))))))))))) + ((cos(\"upright(\"phi1\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1519 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1814", + "entry": { + "target_id": "effect:effect_1814", + "label": "effect_1814", + "plain_source": "upright(\"to_extract\")(1528) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((\"upright(\"phi2\")\") * (((sin(\"upright(\"phi1\")\")) + ((\"upright(\"phi2\")\") * ((((\" - 1 / 2\") * (((cos(\"upright(\"phi1\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((\" - 1 / 6\") * (((\"upright(\"phi2\")\") * (sin(\"upright(\"phi1\")\"))))))))))) + ((cos(\"upright(\"phi1\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1528 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $])) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1822", + "entry": { + "target_id": "effect:effect_1822", + "label": "effect_1822", + "plain_source": "upright(\"to_extract\")(1535) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi2\")\") * (((\"upright(\"phi1\")\") + ((\" - 1 / 2\") * (((\"upright(\"phi2\")\") * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1535 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1832", + "entry": { + "target_id": "effect:effect_1832", + "label": "effect_1832", + "plain_source": "upright(\"to_extract\")(1544) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi2\")\") * (((\"upright(\"phi1\")\") + ((\"upright(\"phi2\")\") * ((((\" - 1 / 2\") * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + ((\" - 1 / 6\") * (((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1544 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1838", + "entry": { + "target_id": "effect:effect_1838", + "label": "effect_1838", + "plain_source": "upright(\"to_extract\")(1549) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")), (upright(\"lower\")(((((\"upright(\"lambda1\")\") + ((((\" - 1 / 1\") * (\"upright(\"phi2\")\")) + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"lambda2\")\")), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1549 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1842", + "entry": { + "target_id": "effect:effect_1842", + "label": "effect_1842", + "plain_source": "upright(\"to_extract\")(1552) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1552 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1849", + "entry": { + "target_id": "effect:effect_1849", + "label": "effect_1849", + "plain_source": "upright(\"to_extract\")(1558) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (((\"upright(\"phi2\")\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1558 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1858", + "entry": { + "target_id": "effect:effect_1858", + "label": "effect_1858", + "plain_source": "upright(\"to_extract\")(1566) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi2\")\") * ((((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\" - 1 / 2\") * (((\"upright(\"phi2\")\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1566 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1868", + "entry": { + "target_id": "effect:effect_1868", + "label": "effect_1868", + "plain_source": "upright(\"to_extract\")(1575) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi2\")\") * ((((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\"upright(\"phi2\")\") * ((((\" - 1 / 2\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\"1 / 6\") * (((\"upright(\"phi2\")\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1575 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1872", + "entry": { + "target_id": "effect:effect_1872", + "label": "effect_1872", + "plain_source": "upright(\"to_extract\")(1578) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi2\")\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1578 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1878", + "entry": { + "target_id": "effect:effect_1878", + "label": "effect_1878", + "plain_source": "upright(\"to_extract\")(1583) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi2\")\") * (((cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\" - 1 / 2\") * (((\"upright(\"phi2\")\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1583 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1887", + "entry": { + "target_id": "effect:effect_1887", + "label": "effect_1887", + "plain_source": "upright(\"to_extract\")(1591) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi2\")\") * (((cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi2\")\") * ((((\" - 1 / 2\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\" - 1 / 6\") * (((\"upright(\"phi2\")\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1591 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1891", + "entry": { + "target_id": "effect:effect_1891", + "label": "effect_1891", + "plain_source": "upright(\"to_extract\")(1594) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")(((\"2 / 1\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1594 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1897", + "entry": { + "target_id": "effect:effect_1897", + "label": "effect_1897", + "plain_source": "upright(\"to_extract\")(1599) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")((((\"2 / 1\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\"upright(\"phi2\")\") * (((cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1599 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1905", + "entry": { + "target_id": "effect:effect_1905", + "label": "effect_1905", + "plain_source": "upright(\"to_extract\")(1606) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")((((\"2 / 1\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\"upright(\"phi2\")\") * (((cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\" - 1 / 1\") * (((\"upright(\"phi2\")\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1606 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1919", + "entry": { + "target_id": "effect:effect_1919", + "label": "effect_1919", + "plain_source": "upright(\"to_extract\")(1619) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")((((\"2 / 1\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\"upright(\"phi2\")\") * (((cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\"upright(\"phi2\")\") * ((((\" - 1 / 1\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\"upright(\"phi2\")\") * ((((\" - 1 / 6\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\"1 / 6\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1619 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) $])) $]) $])) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1924", + "entry": { + "target_id": "effect:effect_1924", + "label": "effect_1924", + "plain_source": "upright(\"to_extract\")(1623) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"1 / 2\") * (((\"upright(\"phi2\")\") * (((cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1623 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1931", + "entry": { + "target_id": "effect:effect_1931", + "label": "effect_1931", + "plain_source": "upright(\"to_extract\")(1629) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi2\")\") * ((((\" - 1 / 2\") * (((\"upright(\"phi2\")\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))) + ((\"1 / 2\") * (((cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1629 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1940", + "entry": { + "target_id": "effect:effect_1940", + "label": "effect_1940", + "plain_source": "upright(\"to_extract\")(1637) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi2\")\") * ((((\"1 / 2\") * (((cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))) + ((\"upright(\"phi2\")\") * ((((\" - 1 / 2\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\"1 / 2\") * (((\"upright(\"phi2\")\") * ((((\" - 1 / 6\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\"1 / 6\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1637 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1946", + "entry": { + "target_id": "effect:effect_1946", + "label": "effect_1946", + "plain_source": "upright(\"to_extract\")(1642) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi2\")\") * (((\"upright(\"phi1\")\") + ((\"1 / 2\") * (((cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1642 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1952", + "entry": { + "target_id": "effect:effect_1952", + "label": "effect_1952", + "plain_source": "upright(\"to_extract\")(1647) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi2\")\") * (((\"upright(\"phi1\")\") + ((((\" - 1 / 2\") * (((\"upright(\"phi2\")\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))) + ((\"1 / 2\") * (((cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1647 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) $])) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1965", + "entry": { + "target_id": "effect:effect_1965", + "label": "effect_1965", + "plain_source": "upright(\"to_extract\")(1659) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi2\")\") * (((\"upright(\"phi1\")\") + ((((\"1 / 2\") * (((cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))) + ((\"upright(\"phi2\")\") * ((((\" - 1 / 2\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\"upright(\"phi2\")\") * ((((\" - 1 / 6\") * (\"upright(\"phi1\")\")) + ((\"1 / 2\") * ((((\" - 1 / 6\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\"1 / 6\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))))))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1659 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) $])) $]) $])) $]) $])) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1969", + "entry": { + "target_id": "effect:effect_1969", + "label": "effect_1969", + "plain_source": "upright(\"to_extract\")(1662) = upright(\"approx\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"phi2\")\") * (sin(\"upright(\"phi1\")\"))) + ((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1662 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1977", + "entry": { + "target_id": "effect:effect_1977", + "label": "effect_1977", + "plain_source": "upright(\"to_extract\")(1669) = upright(\"approx\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"phi2\")\") * (((sin(\"upright(\"phi1\")\")) + ((\" - 1 / 2\") * (((\"upright(\"phi2\")\") * (((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))))))))) + ((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1669 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1985", + "entry": { + "target_id": "effect:effect_1985", + "label": "effect_1985", + "plain_source": "upright(\"to_extract\")(1676) = upright(\"approx\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"phi2\")\") * (((sin(\"upright(\"phi1\")\")) + ((\"upright(\"phi2\")\") * ((((\" - 1 / 2\") * (((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))) + ((\" - 1 / 6\") * (((\"upright(\"phi2\")\") * (sin(\"upright(\"phi1\")\"))))))))))) + ((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1676 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $])) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1988", + "entry": { + "target_id": "effect:effect_1988", + "label": "effect_1988", + "plain_source": "upright(\"to_extract\")(1678) = upright(\"approx\")((sin(\"upright(\"phi2\")\")), (upright(\"lower\")((sin(\"upright(\"phi2\")\")), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1678 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_1994", + "entry": { + "target_id": "effect:effect_1994", + "label": "effect_1994", + "plain_source": "upright(\"to_extract\")(1683) = upright(\"approx\")(((\"1 / 1\") + ((\" - 1 / 2\") * ((\"upright(\"phi2\")\")^(\"2 / 1\")))), (upright(\"lower\")((((\"upright(\"phi2\")\")^(\"2 / 1\")) * (((frac(\"1 / 1\", (\"upright(\"phi2\")\")^(\"2 / 1\"))) - (\"1 / 2\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1683 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_2000", + "entry": { + "target_id": "effect:effect_2000", + "label": "effect_2000", + "plain_source": "upright(\"to_extract\")(1688) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((\"upright(\"phi2\")\") * (((\"upright(\"phi1\")\") + (frac(cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))), \"upright(\"phi2\")\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1688 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_2003", + "entry": { + "target_id": "effect:effect_2003", + "label": "effect_2003", + "plain_source": "upright(\"to_extract\")(1690) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")), (upright(\"lower\")(((\" - 1 / 1\") * (\"upright(\"phi2\")\")), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1690 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_2014", + "entry": { + "target_id": "effect:effect_2014", + "label": "effect_2014", + "plain_source": "upright(\"to_extract\")(1700) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")), (upright(\"lower\")(((\"upright(\"phi2\")\") * ((((((\"1 / 2\") * ((frac(upright(\"pi\"), \"upright(\"phi2\")\")))) + (frac(\"upright(\"lambda1\")\", \"upright(\"phi2\")\")))) - (((\"1 / 1\") + (frac(\"upright(\"lambda2\")\", \"upright(\"phi2\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1700 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_2020", + "entry": { + "target_id": "effect:effect_2020", + "label": "effect_2020", + "plain_source": "upright(\"to_extract\")(1705) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")), (upright(\"lower\")(((\"upright(\"phi2\")\") * (((((\"1 / 1\") + ((((\"1 / 2\") * ((frac(upright(\"pi\"), \"upright(\"phi2\")\")))) + (frac(\"upright(\"lambda1\")\", \"upright(\"phi2\")\")))))) - (frac(\"upright(\"lambda2\")\", \"upright(\"phi2\")\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1705 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_2028", + "entry": { + "target_id": "effect:effect_2028", + "label": "effect_2028", + "plain_source": "upright(\"to_extract\")(1712) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"phi2\")\") * ((((\" - 1 / 1\") * (\"upright(\"phi1\")\")) + ((\" - 1 / 1\") * ((frac(cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))), \"upright(\"phi2\")\"))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1712 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_2036", + "entry": { + "target_id": "effect:effect_2036", + "label": "effect_2036", + "plain_source": "upright(\"to_extract\")(1719) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"phi2\")\") * (((\"1 / 1\") + ((\" - 1 / 1\") * ((frac(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")), \"upright(\"phi2\")\"))))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1719 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_2040", + "entry": { + "target_id": "effect:effect_2040", + "label": "effect_2040", + "plain_source": "upright(\"to_extract\")(1722) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")((sin(((((\"upright(\"lambda1\")\") + ((((\" - 1 / 1\") * (\"upright(\"phi2\")\")) + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"lambda2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1722 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_2046", + "entry": { + "target_id": "effect:effect_2046", + "label": "effect_2046", + "plain_source": "upright(\"to_extract\")(1727) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"phi2\")\") * ((((\" - 1 / 1\") * ((frac(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")), \"upright(\"phi2\")\")))) - (\"1 / 1\")))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1727 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_2052", + "entry": { + "target_id": "effect:effect_2052", + "label": "effect_2052", + "plain_source": "upright(\"to_extract\")(1732) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"phi2\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1732 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_2056", + "entry": { + "target_id": "effect:effect_2056", + "label": "effect_2056", + "plain_source": "upright(\"to_extract\")(1735) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"phi2\")\"))))))) + (sin(((((\"upright(\"lambda1\")\") + ((((\" - 1 / 1\") * (\"upright(\"phi2\")\")) + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"lambda2\")\"))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1735 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_2060", + "entry": { + "target_id": "effect:effect_2060", + "label": "effect_2060", + "plain_source": "upright(\"to_extract\")(1738) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")(((\"1 / 2\") * (((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"phi2\")\"))))))) + (sin(((((\"upright(\"lambda1\")\") + ((((\" - 1 / 1\") * (\"upright(\"phi2\")\")) + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1738 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + }, + { + "kind": "derive", + "id": "effect_2064", + "entry": { + "target_id": "effect:effect_2064", + "label": "effect_2064", + "plain_source": "upright(\"to_extract\")(1741) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")((((\"1 / 2\") * (((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"phi2\")\"))))))) + (sin(((((\"upright(\"lambda1\")\") + ((((\" - 1 / 1\") * (\"upright(\"phi2\")\")) + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"lambda2\")\"))))))) + ((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\")))", + "colored_source": "upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1741 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"Unit\"), \"R\" \\ \"upright(\"lambda1\")\" \\ \"upright(\"lambda2\")\" \\ \"upright(\"phi1\")\" \\ \"upright(\"phi2\")\" \\ upright(\"to_extract\")(13) = upright(\"approx\")(\"upright(\"phi1\")\", (upright(\"lower\")(\"0 / 1\", \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(15) = upright(\"approx\")(\"R\", (upright(\"lower\")(\"R\", \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(34) = upright(\"approx\")(((upright(\"acos\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))))) * (\"R\")), (upright(\"lower\")(((\"R\") * (upright(\"acos\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(52) = upright(\"approx\")(((upright(\"acos\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))))))))) * (\"R\")), (upright(\"lower\")(((\"R\") * (upright(\"acos\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(54) = upright(\"approx\")(\"upright(\"lambda1\")\", (upright(\"lower\")(\"upright(\"lambda1\")\", \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(58) = upright(\"approx\")(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")), (upright(\"lower\")(((\" - 1 / 1\") * (\"upright(\"lambda2\")\")), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(60) = upright(\"approx\")(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")), (upright(\"lower\")(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(64) = upright(\"approx\")((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")((cos((-(\"upright(\"lambda2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(70) = upright(\"approx\")((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")(((cos((-(\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(78) = upright(\"approx\")((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")(((cos((-(\"upright(\"lambda2\")\")))) + ((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (((\"upright(\"lambda1\")\") * (cos((-(\"upright(\"lambda2\")\"))))))) - (sin((-(\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(88) = upright(\"approx\")((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")(((cos((-(\"upright(\"lambda2\")\")))) + ((\"upright(\"lambda1\")\") * ((((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (cos((-(\"upright(\"lambda2\")\"))))) + ((\"1 / 6\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\")))))))))) - (sin((-(\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(90) = upright(\"approx\")(((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(92) = upright(\"approx\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))))), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(95) = upright(\"approx\")((cos(\"upright(\"lambda1\")\")), (upright(\"lower\")(\"1 / 1\", \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(101) = upright(\"approx\")((cos(\"upright(\"lambda1\")\")), (upright(\"lower\")(((\"1 / 1\") + ((\" - 1 / 2\") * ((\"upright(\"lambda1\")\")^(\"2 / 1\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(109) = upright(\"approx\")((cos(\"upright(\"lambda1\")\")), (upright(\"lower\")(((\"1 / 1\") + (((\"upright(\"lambda1\")\")^(\"2 / 1\")) * ((((\"1 / 24\") * ((\"upright(\"lambda1\")\")^(\"2 / 1\"))) - (\"1 / 2\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(118) = upright(\"approx\")((cos(\"upright(\"lambda1\")\")), (upright(\"lower\")(((\"1 / 1\") + (((\"upright(\"lambda1\")\")^(\"2 / 1\")) * (((((\"upright(\"lambda1\")\")^(\"2 / 1\")) * (((\"1 / 24\") + ((\" - 1 / 720\") * ((\"upright(\"lambda1\")\")^(\"2 / 1\")))))) - (\"1 / 2\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(124) = upright(\"approx\")((sin(\"upright(\"lambda1\")\")), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (((\"1 / 1\") + ((\" - 1 / 6\") * ((\"upright(\"lambda1\")\")^(\"2 / 1\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(132) = upright(\"approx\")((sin(\"upright(\"lambda1\")\")), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (((\"1 / 1\") + (((\"upright(\"lambda1\")\")^(\"2 / 1\")) * ((((\"1 / 120\") * ((\"upright(\"lambda1\")\")^(\"2 / 1\"))) - (\"1 / 6\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(142) = upright(\"approx\")((sin(\"upright(\"lambda1\")\")), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (((\"1 / 1\") + (((\"upright(\"lambda1\")\")^(\"2 / 1\")) * (((((\"upright(\"lambda1\")\")^(\"2 / 1\")) * (((\"1 / 120\") + ((\" - 1 / 5040\") * ((\"upright(\"lambda1\")\")^(\"2 / 1\")))))) - (\"1 / 6\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(145) = upright(\"approx\")(((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (sin(\"upright(\"lambda2\")\"))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(151) = upright(\"approx\")(((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (((sin(\"upright(\"lambda2\")\")) + ((\" - 1 / 6\") * ((((\"upright(\"lambda1\")\")^(\"2 / 1\")) * (sin(\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(159) = upright(\"approx\")(((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (((sin(\"upright(\"lambda2\")\")) + (((\"upright(\"lambda1\")\")^(\"2 / 1\")) * ((((\" - 1 / 6\") * (sin(\"upright(\"lambda2\")\"))) + ((\"1 / 120\") * ((((\"upright(\"lambda1\")\")^(\"2 / 1\")) * (sin(\"upright(\"lambda2\")\"))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(169) = upright(\"approx\")(((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (((sin(\"upright(\"lambda2\")\")) + (((\"upright(\"lambda1\")\")^(\"2 / 1\")) * ((((\" - 1 / 6\") * (sin(\"upright(\"lambda2\")\"))) + (((\"upright(\"lambda1\")\")^(\"2 / 1\")) * ((((\" - 1 / 5040\") * ((((\"upright(\"lambda1\")\")^(\"2 / 1\")) * (sin(\"upright(\"lambda2\")\"))))) + ((\"1 / 120\") * (sin(\"upright(\"lambda2\")\")))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(171) = upright(\"approx\")((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))), (upright(\"lower\")((cos(\"upright(\"lambda2\")\")), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(174) = upright(\"approx\")((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))), (upright(\"lower\")(((cos(\"upright(\"lambda2\")\")) + ((\"upright(\"lambda1\")\") * (sin(\"upright(\"lambda2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(181) = upright(\"approx\")((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))), (upright(\"lower\")(((cos(\"upright(\"lambda2\")\")) + ((\"upright(\"lambda1\")\") * (((sin(\"upright(\"lambda2\")\")) + ((\" - 1 / 2\") * (((\"upright(\"lambda1\")\") * (cos(\"upright(\"lambda2\")\"))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(190) = upright(\"approx\")((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))), (upright(\"lower\")(((cos(\"upright(\"lambda2\")\")) + ((\"upright(\"lambda1\")\") * (((sin(\"upright(\"lambda2\")\")) + ((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (cos(\"upright(\"lambda2\")\"))) + ((\" - 1 / 6\") * (((\"upright(\"lambda1\")\") * (sin(\"upright(\"lambda2\")\")))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(194) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")(((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(201) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")((((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin((-(\"upright(\"lambda2\")\"))))))))))) + ((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(209) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")((((\"upright(\"lambda1\")\") * ((((\" - 1 / 1\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin((-(\"upright(\"lambda2\")\"))))))))) + ((\" - 1 / 2\") * (((\"upright(\"lambda1\")\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\")))))))))))))) + ((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(218) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")((((\"upright(\"lambda1\")\") * ((((\" - 1 / 1\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin((-(\"upright(\"lambda2\")\"))))))))) + ((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\"))))))))) + ((\"1 / 6\") * (((\"upright(\"lambda1\")\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin((-(\"upright(\"lambda2\")\"))))))))))))))))) + ((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(221) = upright(\"approx\")(((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), (upright(\"lower\")(((cos(\"upright(\"lambda2\")\")) * (cos(\"upright(\"phi2\")\"))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(226) = upright(\"approx\")(((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"lambda1\")\") * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda2\")\"))))) + ((cos(\"upright(\"lambda2\")\")) * (cos(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(233) = upright(\"approx\")(((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (((\"upright(\"lambda1\")\") * (((cos(\"upright(\"lambda2\")\")) * (cos(\"upright(\"phi2\")\"))))))) + ((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda2\")\")))))) + ((cos(\"upright(\"lambda2\")\")) * (cos(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(242) = upright(\"approx\")(((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"lambda1\")\") * ((((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (((cos(\"upright(\"lambda2\")\")) * (cos(\"upright(\"phi2\")\"))))) + ((\" - 1 / 6\") * (((\"upright(\"lambda1\")\") * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda2\")\")))))))))) + ((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda2\")\")))))) + ((cos(\"upright(\"lambda2\")\")) * (cos(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(246) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((cos(\"upright(\"lambda2\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(251) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((\"upright(\"lambda1\")\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda2\")\"))))))) + ((((cos(\"upright(\"lambda2\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(258) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (((\"upright(\"lambda1\")\") * (((cos(\"upright(\"lambda2\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))))))) + ((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((((cos(\"upright(\"lambda2\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(267) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((\"upright(\"lambda1\")\") * ((((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (((cos(\"upright(\"lambda2\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))))) + ((\" - 1 / 6\") * (((\"upright(\"lambda1\")\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda2\")\")))))))))))) + ((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((((cos(\"upright(\"lambda2\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(272) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos((-(\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(276) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos((-(\"upright(\"lambda2\")\")))) + ((((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(280) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos((-(\"upright(\"lambda2\")\")))) + ((((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (((\"upright(\"lambda1\")\") * (cos((-(\"upright(\"lambda2\")\"))))))) - (sin((-(\"upright(\"lambda2\")\"))))))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(284) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos((-(\"upright(\"lambda2\")\")))) + ((((\"upright(\"lambda1\")\") * ((((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (cos((-(\"upright(\"lambda2\")\"))))) + ((\"1 / 6\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\")))))))))) - (sin((-(\"upright(\"lambda2\")\"))))))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(289) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(294) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (((cos(\"upright(\"phi2\")\")) * (sin((-(\"upright(\"lambda2\")\"))))))))) + ((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(302) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"lambda1\")\") * ((((\" - 1 / 1\") * (((cos(\"upright(\"phi2\")\")) * (sin((-(\"upright(\"lambda2\")\"))))))) + ((\" - 1 / 2\") * (((\"upright(\"lambda1\")\") * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\")))))))))))) + ((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(311) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"lambda1\")\") * ((((\" - 1 / 1\") * (((cos(\"upright(\"phi2\")\")) * (sin((-(\"upright(\"lambda2\")\"))))))) + ((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\"))))))) + ((\"1 / 6\") * (((\"upright(\"lambda1\")\") * (((cos(\"upright(\"phi2\")\")) * (sin((-(\"upright(\"lambda2\")\"))))))))))))))) + ((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(317) = upright(\"approx\")((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")((((\"1 / 2\") * (upright(\"pi\"))) - (\"upright(\"lambda2\")\")), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(321) = upright(\"approx\")((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(326) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")), (upright(\"lower\")((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(329) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")), (upright(\"lower\")(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(333) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(338) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + ((\"upright(\"lambda1\")\") * (cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(345) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + ((\"upright(\"lambda1\")\") * (((cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + ((\" - 1 / 2\") * (((\"upright(\"lambda1\")\") * (sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\"))))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(354) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + ((\"upright(\"lambda1\")\") * (((cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + ((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\"))))))) + ((\" - 1 / 6\") * (((\"upright(\"lambda1\")\") * (cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(359) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")), (upright(\"lower\")(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(363) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")), (upright(\"lower\")(((((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"lambda2\")\")), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(367) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")((sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(372) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"lambda1\")\") * (cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(379) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"lambda1\")\") * (((cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\" - 1 / 2\") * (((\"upright(\"lambda1\")\") * (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(388) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"lambda1\")\") * (((cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\" - 1 / 6\") * (((\"upright(\"lambda1\")\") * (cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(392) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")(((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(398) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")(((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (((sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"lambda1\")\") * (((cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(407) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")(((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (((sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"lambda1\")\") * (((cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (((cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\"))))))) + ((\" - 1 / 2\") * (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(421) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")(((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (((sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"lambda1\")\") * (((cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (((cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\"))))))) + ((((\" - 1 / 2\") * (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\"upright(\"lambda1\")\") * ((((\" - 1 / 6\") * (cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\"))))))) + ((\" - 1 / 6\") * (cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))))))))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(425) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")(((\"1 / 2\") * (((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(429) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")((((\"1 / 2\") * (((\"upright(\"lambda1\")\") * (((cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))))) + ((\"1 / 2\") * (((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(436) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")((((\"1 / 2\") * (((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))) + ((\"upright(\"lambda1\")\") * ((((\"1 / 2\") * (((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\"))))))) + ((\" - 1 / 2\") * (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))) + ((\"1 / 2\") * (((cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(445) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")((((\"1 / 2\") * (((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))) + ((\"upright(\"lambda1\")\") * ((((\"1 / 2\") * (((cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))) + ((\"upright(\"lambda1\")\") * ((((\"1 / 2\") * (((\"upright(\"lambda1\")\") * ((((\" - 1 / 6\") * (cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\"))))))) + ((\" - 1 / 6\") * (cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))) + ((\"1 / 2\") * ((((\" - 1 / 2\") * (sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\"))))))) + ((\" - 1 / 2\") * (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(449) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")((((\"1 / 2\") * (((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))) + ((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(452) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")((((\"1 / 2\") * (((\"upright(\"lambda1\")\") * (((cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))))) + ((((\"1 / 2\") * (((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))) + ((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(456) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")((((\"1 / 2\") * (((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))) + ((((\"upright(\"lambda1\")\") * ((((\"1 / 2\") * (((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\"))))))) + ((\" - 1 / 2\") * (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))) + ((\"1 / 2\") * (((cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))) + ((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(460) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")((((\"1 / 2\") * (((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))) + ((((\"upright(\"lambda1\")\") * ((((\"1 / 2\") * (((cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))) + ((\"upright(\"lambda1\")\") * ((((\"1 / 2\") * (((\"upright(\"lambda1\")\") * ((((\" - 1 / 6\") * (cos((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\"))))))) + ((\" - 1 / 6\") * (cos(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))) + ((\"1 / 2\") * ((((\" - 1 / 2\") * (sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\"))))))) + ((\" - 1 / 2\") * (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))))))) + ((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(463) = upright(\"approx\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\"))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(466) = upright(\"approx\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin((-(\"upright(\"lambda2\")\"))))))))))) + ((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\"))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(469) = upright(\"approx\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"lambda1\")\") * ((((\" - 1 / 1\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin((-(\"upright(\"lambda2\")\"))))))))) + ((\" - 1 / 2\") * (((\"upright(\"lambda1\")\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\")))))))))))))) + ((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\"))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(472) = upright(\"approx\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"lambda1\")\") * ((((\" - 1 / 1\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin((-(\"upright(\"lambda2\")\"))))))))) + ((\"upright(\"lambda1\")\") * ((((\" - 1 / 2\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\"))))))))) + ((\"1 / 6\") * (((\"upright(\"lambda1\")\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin((-(\"upright(\"lambda2\")\"))))))))))))))))) + ((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(\"upright(\"lambda2\")\"))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(474) = upright(\"approx\")((upright(\"acos\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))))), (upright(\"lower\")((upright(\"acos\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(476) = upright(\"approx\")((upright(\"acos\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))))))))), (upright(\"lower\")((upright(\"acos\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(482) = upright(\"approx\")(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (((\"1 / 1\") + ((\" - 1 / 1\") * ((frac(\"upright(\"lambda2\")\", \"upright(\"lambda1\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(484) = upright(\"approx\")((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(490) = upright(\"approx\")(((cos((-(\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\")))))))), (upright(\"lower\")(((\"upright(\"lambda1\")\") * ((((\" - 1 / 1\") * (sin((-(\"upright(\"lambda2\")\"))))) + (frac(cos((-(\"upright(\"lambda2\")\"))), \"upright(\"lambda1\")\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(492) = upright(\"approx\")((cos(\"upright(\"lambda1\")\")), (upright(\"lower\")((cos(\"upright(\"lambda1\")\")), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(494) = upright(\"approx\")((sin(\"upright(\"lambda1\")\")), (upright(\"lower\")((sin(\"upright(\"lambda1\")\")), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(496) = upright(\"approx\")(((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))), (upright(\"lower\")(((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(498) = upright(\"approx\")((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))), (upright(\"lower\")((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(500) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")(((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(502) = upright(\"approx\")(((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), (upright(\"lower\")(((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(504) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(506) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(508) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(515) = upright(\"approx\")((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (((((\"1 / 1\") + ((\"1 / 2\") * ((frac(upright(\"pi\"), \"upright(\"lambda1\")\")))))) - (frac(\"upright(\"lambda2\")\", \"upright(\"lambda1\")\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(521) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (((((\"1 / 1\") + ((\"1 / 2\") * ((frac(upright(\"pi\"), \"upright(\"lambda1\")\")))))) - (((frac(\"upright(\"lambda2\")\", \"upright(\"lambda1\")\")) + (frac(\"upright(\"phi2\")\", \"upright(\"lambda1\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(524) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(530) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (((((\"1 / 1\") + ((((\"1 / 2\") * ((frac(upright(\"pi\"), \"upright(\"lambda1\")\")))) + (frac(\"upright(\"phi2\")\", \"upright(\"lambda1\")\")))))) - (frac(\"upright(\"lambda2\")\", \"upright(\"lambda1\")\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(533) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")((sin(((((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"lambda2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(536) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"lambda2\")\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(539) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")(((\"1 / 2\") * (((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(542) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")((((\"1 / 2\") * (((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"lambda2\")\"))))))) + ((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(544) = upright(\"approx\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(549) = upright(\"approx\")(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (((frac(\"upright(\"lambda2\")\", \"upright(\"lambda1\")\")) - (\"1 / 1\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(555) = upright(\"approx\")((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")((cos((-(((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(561) = upright(\"approx\")(((cos((-(\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\")))))))), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (((sin((-(\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * ((frac(cos((-(\"upright(\"lambda2\")\"))), \"upright(\"lambda1\")\"))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(565) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")(((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\")))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(568) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos((-(((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\"))))))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(571) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos((-(((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\"))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(578) = upright(\"approx\")((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * ((((\" - 1 / 1\") * ((frac((((\"1 / 2\") * (upright(\"pi\"))) - (\"upright(\"lambda2\")\")), \"upright(\"lambda1\")\")))) - (\"1 / 1\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(585) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * ((((\" - 1 / 1\") * ((frac((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))), \"upright(\"lambda1\")\")))) - (\"1 / 1\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(591) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (((\"upright(\"phi2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\"))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(598) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * ((((\" - 1 / 1\") * ((frac(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")), \"upright(\"lambda1\")\")))) - (\"1 / 1\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(602) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")((sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(605) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")(((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (((\"upright(\"phi2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\"))))))))) + (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\")))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(608) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")(((\"1 / 2\") * (((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (((\"upright(\"phi2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\"))))))))) + (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\")))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(611) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")((((\"1 / 2\") * (((sin((((\"1 / 2\") * (upright(\"pi\"))) - (((\"upright(\"lambda2\")\") + (((\"upright(\"phi2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\"))))))))) + (sin(((((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\")))))))))) + ((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(614) = upright(\"approx\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\")))))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(617) = upright(\"approx\")((upright(\"acos\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))))), (upright(\"lower\")((upright(\"acos\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\")))))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(620) = upright(\"approx\")(((upright(\"acos\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))))) * (\"R\")), (upright(\"lower\")(((\"R\") * (upright(\"acos\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos((-(((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda1\")\")))))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(622) = upright(\"approx\")(\"upright(\"lambda2\")\", (upright(\"lower\")(\"upright(\"lambda2\")\", \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(625) = upright(\"approx\")(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")), (upright(\"lower\")(((\"upright(\"lambda1\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda2\")\"))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(629) = upright(\"approx\")((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")(((cos(\"upright(\"lambda1\")\")) + ((\"upright(\"lambda2\")\") * (sin(\"upright(\"lambda1\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(637) = upright(\"approx\")((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")(((cos(\"upright(\"lambda1\")\")) + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (((\"upright(\"lambda2\")\") * (cos(\"upright(\"lambda1\")\"))))) - ((\" - 1 / 1\") * (sin(\"upright(\"lambda1\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(646) = upright(\"approx\")((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")(((cos(\"upright(\"lambda1\")\")) + ((\"upright(\"lambda2\")\") * ((((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (cos(\"upright(\"lambda1\")\"))) + ((\" - 1 / 6\") * (((\"upright(\"lambda2\")\") * (sin(\"upright(\"lambda1\")\")))))))) - ((\" - 1 / 1\") * (sin(\"upright(\"lambda1\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(651) = upright(\"approx\")((cos((-(\"upright(\"lambda2\")\")))), (upright(\"lower\")(((\"1 / 1\") + ((\" - 1 / 2\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(657) = upright(\"approx\")((cos((-(\"upright(\"lambda2\")\")))), (upright(\"lower\")(((\"1 / 1\") + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * ((((\"1 / 24\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\"))) - (\"1 / 2\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(665) = upright(\"approx\")((cos((-(\"upright(\"lambda2\")\")))), (upright(\"lower\")(((\"1 / 1\") + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * (((((\"upright(\"lambda2\")\")^(\"2 / 1\")) * (((\"1 / 24\") + ((\" - 1 / 720\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\")))))) - (\"1 / 2\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(670) = upright(\"approx\")((sin((-(\"upright(\"lambda2\")\")))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * ((((\"1 / 6\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\"))) - (\"1 / 1\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(678) = upright(\"approx\")((sin((-(\"upright(\"lambda2\")\")))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * (((((\"upright(\"lambda2\")\")^(\"2 / 1\")) * (((\"1 / 6\") + ((\" - 1 / 120\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\")))))) - (\"1 / 1\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(688) = upright(\"approx\")((sin((-(\"upright(\"lambda2\")\")))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * (((((\"upright(\"lambda2\")\")^(\"2 / 1\")) * (((\"1 / 6\") + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * ((((\"1 / 5040\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\"))) - (\"1 / 120\"))))))) - (\"1 / 1\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(692) = upright(\"approx\")(((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (\"upright(\"lambda2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(698) = upright(\"approx\")(((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * ((((\" - 1 / 1\") * (\"upright(\"lambda1\")\")) + ((\"1 / 6\") * (((\"upright(\"lambda1\")\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\")))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(706) = upright(\"approx\")(((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * ((((\" - 1 / 1\") * (\"upright(\"lambda1\")\")) + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * ((((\" - 1 / 120\") * (((\"upright(\"lambda1\")\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\"))))) + ((\"1 / 6\") * (\"upright(\"lambda1\")\")))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(716) = upright(\"approx\")(((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * ((((\" - 1 / 1\") * (\"upright(\"lambda1\")\")) + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * ((((\"1 / 6\") * (\"upright(\"lambda1\")\")) + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * ((((\" - 1 / 120\") * (\"upright(\"lambda1\")\")) + ((\"1 / 5040\") * (((\"upright(\"lambda1\")\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\")))))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(718) = upright(\"approx\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))))), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (\"upright(\"lambda2\")\")), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(723) = upright(\"approx\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * (((\"upright(\"lambda1\")\") + ((\" - 1 / 6\") * (((\"upright(\"lambda1\")\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\")))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(731) = upright(\"approx\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * (((\"upright(\"lambda1\")\") + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * ((((\" - 1 / 6\") * (\"upright(\"lambda1\")\")) + ((\"1 / 120\") * (((\"upright(\"lambda1\")\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\"))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(741) = upright(\"approx\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * (((\"upright(\"lambda1\")\") + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * ((((\" - 1 / 6\") * (\"upright(\"lambda1\")\")) + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * ((((\" - 1 / 5040\") * (((\"upright(\"lambda1\")\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\"))))) + ((\"1 / 120\") * (\"upright(\"lambda1\")\"))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(744) = upright(\"approx\")(((cos((-(\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\")))))))), (upright(\"lower\")(((\"1 / 1\") + ((\"upright(\"lambda1\")\") * (\"upright(\"lambda2\")\"))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(750) = upright(\"approx\")(((cos((-(\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\")))))))), (upright(\"lower\")(((\"1 / 1\") + ((\"upright(\"lambda2\")\") * (((\"upright(\"lambda1\")\") + ((\" - 1 / 2\") * (\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(758) = upright(\"approx\")(((cos((-(\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\")))))))), (upright(\"lower\")(((\"1 / 1\") + ((\"upright(\"lambda2\")\") * (((\"upright(\"lambda1\")\") + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 6\") * (((\"upright(\"lambda1\")\") * (\"upright(\"lambda2\")\")))) - (\"1 / 2\")))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(763) = upright(\"approx\")((sin(\"upright(\"lambda2\")\")), (upright(\"lower\")(((\"upright(\"lambda2\")\") * (((\"1 / 1\") + ((\" - 1 / 6\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(770) = upright(\"approx\")((sin(\"upright(\"lambda2\")\")), (upright(\"lower\")(((\"upright(\"lambda2\")\") * (((\"1 / 1\") + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * ((((\"1 / 120\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\"))) - (\"1 / 6\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(779) = upright(\"approx\")((sin(\"upright(\"lambda2\")\")), (upright(\"lower\")(((\"upright(\"lambda2\")\") * (((\"1 / 1\") + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * (((((\"upright(\"lambda2\")\")^(\"2 / 1\")) * (((\"1 / 120\") + ((\" - 1 / 5040\") * ((\"upright(\"lambda2\")\")^(\"2 / 1\")))))) - (\"1 / 6\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(781) = upright(\"approx\")(((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * (sin(\"upright(\"lambda1\")\"))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(787) = upright(\"approx\")(((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * (((sin(\"upright(\"lambda1\")\")) + ((\" - 1 / 6\") * ((((\"upright(\"lambda2\")\")^(\"2 / 1\")) * (sin(\"upright(\"lambda1\")\")))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(795) = upright(\"approx\")(((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * (((sin(\"upright(\"lambda1\")\")) + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * ((((\" - 1 / 6\") * (sin(\"upright(\"lambda1\")\"))) + ((\"1 / 120\") * ((((\"upright(\"lambda2\")\")^(\"2 / 1\")) * (sin(\"upright(\"lambda1\")\"))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(805) = upright(\"approx\")(((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * (((sin(\"upright(\"lambda1\")\")) + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * ((((\" - 1 / 6\") * (sin(\"upright(\"lambda1\")\"))) + (((\"upright(\"lambda2\")\")^(\"2 / 1\")) * ((((\" - 1 / 5040\") * ((((\"upright(\"lambda2\")\")^(\"2 / 1\")) * (sin(\"upright(\"lambda1\")\"))))) + ((\"1 / 120\") * (sin(\"upright(\"lambda1\")\")))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(810) = upright(\"approx\")((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))), (upright(\"lower\")(((cos(\"upright(\"lambda1\")\")) + ((\"upright(\"lambda2\")\") * (((sin(\"upright(\"lambda1\")\")) + ((\" - 1 / 2\") * (((\"upright(\"lambda2\")\") * (cos(\"upright(\"lambda1\")\"))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(815) = upright(\"approx\")((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))), (upright(\"lower\")(((cos(\"upright(\"lambda1\")\")) + ((\"upright(\"lambda2\")\") * (((sin(\"upright(\"lambda1\")\")) + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (cos(\"upright(\"lambda1\")\"))) + ((\" - 1 / 6\") * (((\"upright(\"lambda2\")\") * (sin(\"upright(\"lambda1\")\")))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(818) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")(((cos(\"upright(\"lambda1\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(824) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")((((\"upright(\"lambda2\")\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\"))))))) + ((cos(\"upright(\"lambda1\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(831) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")((((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (((\"upright(\"lambda2\")\") * (((cos(\"upright(\"lambda1\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))))))) + ((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\")))))))) + ((cos(\"upright(\"lambda1\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(840) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")((((\"upright(\"lambda2\")\") * ((((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (((cos(\"upright(\"lambda1\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))))) + ((\" - 1 / 6\") * (((\"upright(\"lambda2\")\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\")))))))))))) + ((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\")))))))) + ((cos(\"upright(\"lambda1\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(843) = upright(\"approx\")(((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), (upright(\"lower\")(((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"phi2\")\"))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(847) = upright(\"approx\")(((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"lambda2\")\") * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\"))))) + ((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(854) = upright(\"approx\")(((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (((\"upright(\"lambda2\")\") * (((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"phi2\")\"))))))) + ((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\")))))) + ((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(863) = upright(\"approx\")(((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"lambda2\")\") * ((((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"phi2\")\"))))) + ((\" - 1 / 6\") * (((\"upright(\"lambda2\")\") * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\")))))))))) + ((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\")))))) + ((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(866) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((cos(\"upright(\"lambda1\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(869) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((\"upright(\"lambda2\")\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\"))))))) + ((((cos(\"upright(\"lambda1\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(872) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (((\"upright(\"lambda2\")\") * (((cos(\"upright(\"lambda1\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))))))) + ((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\")))))))) + ((((cos(\"upright(\"lambda1\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(875) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((\"upright(\"lambda2\")\") * ((((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (((cos(\"upright(\"lambda1\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))))) + ((\" - 1 / 6\") * (((\"upright(\"lambda2\")\") * (((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\")))))))))))) + ((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\")))))))) + ((((cos(\"upright(\"lambda1\")\")) * (((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(878) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos(\"upright(\"lambda1\")\")) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(882) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos(\"upright(\"lambda1\")\")) + ((((\"upright(\"lambda2\")\") * (sin(\"upright(\"lambda1\")\"))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(886) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos(\"upright(\"lambda1\")\")) + ((((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (((\"upright(\"lambda2\")\") * (cos(\"upright(\"lambda1\")\"))))) - ((\" - 1 / 1\") * (sin(\"upright(\"lambda1\")\")))))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(890) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos(\"upright(\"lambda1\")\")) + ((((\"upright(\"lambda2\")\") * ((((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (cos(\"upright(\"lambda1\")\"))) + ((\" - 1 / 6\") * (((\"upright(\"lambda2\")\") * (sin(\"upright(\"lambda1\")\")))))))) - ((\" - 1 / 1\") * (sin(\"upright(\"lambda1\")\")))))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(893) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(896) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"lambda2\")\") * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\"))))) + ((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(899) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (((\"upright(\"lambda2\")\") * (((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"phi2\")\"))))))) + ((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\")))))) + ((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(902) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"lambda2\")\") * ((((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"phi2\")\"))))) + ((\" - 1 / 6\") * (((\"upright(\"lambda2\")\") * (((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\")))))))))) + ((cos(\"upright(\"phi2\")\")) * (sin(\"upright(\"lambda1\")\")))))) + ((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(904) = upright(\"approx\")((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")(((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(908) = upright(\"approx\")((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")(((\"upright(\"lambda1\")\") + ((((\" - 1 / 1\") * (\"upright(\"lambda2\")\")) + ((\"1 / 2\") * (upright(\"pi\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(911) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")), (upright(\"lower\")(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(914) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")), (upright(\"lower\")(((((\"upright(\"lambda1\")\") + ((((\" - 1 / 1\") * (\"upright(\"lambda2\")\")) + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"phi2\")\")), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(917) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(923) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))) + ((\" - 1 / 1\") * (((\"upright(\"lambda2\")\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(931) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))) + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))) + ((\" - 1 / 2\") * (((\"upright(\"lambda2\")\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(940) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))) + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))) + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))) + ((\"1 / 6\") * (((\"upright(\"lambda2\")\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(942) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")), (upright(\"lower\")(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(946) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")), (upright(\"lower\")(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((((\" - 1 / 1\") * (\"upright(\"lambda2\")\")) + ((\"1 / 2\") * (upright(\"pi\")))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(949) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(955) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + ((\" - 1 / 1\") * (((\"upright(\"lambda2\")\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(963) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 1\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\" - 1 / 2\") * (((\"upright(\"lambda2\")\") * (sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(972) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 1\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\"1 / 6\") * (((\"upright(\"lambda2\")\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(975) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")(((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(981) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")(((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + (((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))) + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 1\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(990) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")(((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + (((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))) + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 1\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))) + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\" - 1 / 2\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1004) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")(((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + (((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))) + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 1\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))) + ((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((((\" - 1 / 2\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))) + ((\"upright(\"lambda2\")\") * ((((\"1 / 6\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\"1 / 6\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))))))))))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1007) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")(((\"1 / 2\") * (((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1011) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")((((\"1 / 2\") * (((\"upright(\"lambda2\")\") * ((((\" - 1 / 1\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))))) + ((\"1 / 2\") * (((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1018) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")((((\"1 / 2\") * (((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))))) + ((\"upright(\"lambda2\")\") * ((((\"1 / 2\") * (((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\" - 1 / 2\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))))) + ((\"1 / 2\") * ((((\" - 1 / 1\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1027) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")((((\"1 / 2\") * (((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))))) + ((\"upright(\"lambda2\")\") * ((((\"1 / 2\") * ((((\" - 1 / 1\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))) + ((\"upright(\"lambda2\")\") * ((((\"1 / 2\") * (((\"upright(\"lambda2\")\") * ((((\"1 / 6\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\"1 / 6\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))))) + ((\"1 / 2\") * ((((\" - 1 / 2\") * (sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\" - 1 / 2\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1030) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")((((\"1 / 2\") * (((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))))) + ((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1033) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")((((\"1 / 2\") * (((\"upright(\"lambda2\")\") * ((((\" - 1 / 1\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))))) + ((((\"1 / 2\") * (((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))))) + ((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1037) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")((((\"1 / 2\") * (((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))))) + ((((\"upright(\"lambda2\")\") * ((((\"1 / 2\") * (((\"upright(\"lambda2\")\") * ((((\" - 1 / 2\") * (sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\" - 1 / 2\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))))) + ((\"1 / 2\") * ((((\" - 1 / 1\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))))))))) + ((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1041) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")((((\"1 / 2\") * (((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))))) + (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\"))))))) + ((((\"upright(\"lambda2\")\") * ((((\"1 / 2\") * ((((\" - 1 / 1\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))) + ((\"upright(\"lambda2\")\") * ((((\"1 / 2\") * (((\"upright(\"lambda2\")\") * ((((\"1 / 6\") * (cos(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\"1 / 6\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))))) + ((\"1 / 2\") * ((((\" - 1 / 2\") * (sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))))) + ((\" - 1 / 2\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")))))))))))))) + ((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1046) = upright(\"approx\")(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")), (upright(\"lower\")(((\"upright(\"lambda2\")\") * (((frac(\"upright(\"lambda1\")\", \"upright(\"lambda2\")\")) - (\"1 / 1\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1048) = upright(\"approx\")((sin((-(\"upright(\"lambda2\")\")))), (upright(\"lower\")((sin((-(\"upright(\"lambda2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1050) = upright(\"approx\")((sin(\"upright(\"lambda2\")\")), (upright(\"lower\")((sin(\"upright(\"lambda2\")\")), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1057) = upright(\"approx\")((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")(((\"upright(\"lambda2\")\") * ((((((\"1 / 2\") * ((frac(upright(\"pi\"), \"upright(\"lambda2\")\")))) + (frac(\"upright(\"lambda1\")\", \"upright(\"lambda2\")\")))) - (\"1 / 1\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1063) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")), (upright(\"lower\")(((\"upright(\"lambda2\")\") * ((((((\"1 / 2\") * ((frac(upright(\"pi\"), \"upright(\"lambda2\")\")))) + (frac(\"upright(\"lambda1\")\", \"upright(\"lambda2\")\")))) - (((\"1 / 1\") + (frac(\"upright(\"phi2\")\", \"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1069) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")), (upright(\"lower\")(((\"upright(\"lambda2\")\") * ((((((\"1 / 2\") * ((frac(upright(\"pi\"), \"upright(\"lambda2\")\")))) + (((frac(\"upright(\"lambda1\")\", \"upright(\"lambda2\")\")) + (frac(\"upright(\"phi2\")\", \"upright(\"lambda2\")\")))))) - (\"1 / 1\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1075) = upright(\"approx\")(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"lambda2\")\") * (((\"1 / 1\") + ((\" - 1 / 1\") * ((frac(\"upright(\"lambda1\")\", \"upright(\"lambda2\")\"))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1078) = upright(\"approx\")((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")((cos(((\"upright(\"lambda1\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda2\")\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1081) = upright(\"approx\")((cos((-(\"upright(\"lambda2\")\")))), (upright(\"lower\")((cos(((\" - 1 / 1\") * (\"upright(\"lambda2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1084) = upright(\"approx\")((sin((-(\"upright(\"lambda2\")\")))), (upright(\"lower\")((sin(((\" - 1 / 1\") * (\"upright(\"lambda2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1087) = upright(\"approx\")(((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))), (upright(\"lower\")(((\"upright(\"lambda1\")\") * (sin(((\" - 1 / 1\") * (\"upright(\"lambda2\")\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1090) = upright(\"approx\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\"))))))), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin(((\" - 1 / 1\") * (\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1093) = upright(\"approx\")(((cos((-(\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin((-(\"upright(\"lambda2\")\")))))))), (upright(\"lower\")(((cos(((\" - 1 / 1\") * (\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (((\"upright(\"lambda1\")\") * (sin(((\" - 1 / 1\") * (\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1097) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")(((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1100) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos(((\"upright(\"lambda1\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda2\")\"))))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1103) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1110) = upright(\"approx\")((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"lambda2\")\") * (((\"1 / 1\") + ((\" - 1 / 1\") * ((frac(((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\")))), \"upright(\"lambda2\")\"))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1117) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"lambda2\")\") * (((\"1 / 1\") + ((\" - 1 / 1\") * ((frac(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"phi2\")\")), \"upright(\"lambda2\")\"))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1120) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")((sin(((((\"upright(\"lambda1\")\") + ((((\" - 1 / 1\") * (\"upright(\"lambda2\")\")) + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"phi2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1127) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"lambda2\")\") * (((\"1 / 1\") + ((\" - 1 / 1\") * ((frac(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\")))))), \"upright(\"lambda2\")\"))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1130) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((((\" - 1 / 1\") * (\"upright(\"lambda2\")\")) + ((\"1 / 2\") * (upright(\"pi\")))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1133) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")(((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((((\" - 1 / 1\") * (\"upright(\"lambda2\")\")) + ((\"1 / 2\") * (upright(\"pi\")))))))))) + (sin(((((\"upright(\"lambda1\")\") + ((((\" - 1 / 1\") * (\"upright(\"lambda2\")\")) + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"phi2\")\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1136) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")(((\"1 / 2\") * (((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((((\" - 1 / 1\") * (\"upright(\"lambda2\")\")) + ((\"1 / 2\") * (upright(\"pi\")))))))))) + (sin(((((\"upright(\"lambda1\")\") + ((((\" - 1 / 1\") * (\"upright(\"lambda2\")\")) + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"phi2\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1139) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")((((\"1 / 2\") * (((sin(((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((((\" - 1 / 1\") * (\"upright(\"lambda2\")\")) + ((\"1 / 2\") * (upright(\"pi\")))))))))) + (sin(((((\"upright(\"lambda1\")\") + ((((\" - 1 / 1\") * (\"upright(\"lambda2\")\")) + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"phi2\")\"))))))) + ((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1142) = upright(\"approx\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1145) = upright(\"approx\")((upright(\"acos\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))))), (upright(\"lower\")((upright(\"acos\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1148) = upright(\"approx\")(((upright(\"acos\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))))) * (\"R\")), (upright(\"lower\")(((\"R\") * (upright(\"acos\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") + ((\" - 1 / 1\") * (\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1150) = upright(\"approx\")(\"upright(\"phi1\")\", (upright(\"lower\")(\"upright(\"phi1\")\", \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1156) = upright(\"approx\")((sin(\"upright(\"phi1\")\")), (upright(\"lower\")(((\"upright(\"phi1\")\") * (((\"1 / 1\") + ((\" - 1 / 6\") * ((\"upright(\"phi1\")\")^(\"2 / 1\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1163) = upright(\"approx\")((sin(\"upright(\"phi1\")\")), (upright(\"lower\")(((\"upright(\"phi1\")\") * (((\"1 / 1\") + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\"1 / 120\") * ((\"upright(\"phi1\")\")^(\"2 / 1\"))) - (\"1 / 6\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1172) = upright(\"approx\")((sin(\"upright(\"phi1\")\")), (upright(\"lower\")(((\"upright(\"phi1\")\") * (((\"1 / 1\") + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * (((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (((\"1 / 120\") + ((\" - 1 / 5040\") * ((\"upright(\"phi1\")\")^(\"2 / 1\")))))) - (\"1 / 6\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1174) = upright(\"approx\")(((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))), (upright(\"lower\")(((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1180) = upright(\"approx\")(((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))), (upright(\"lower\")(((\"upright(\"phi1\")\") * (((sin(\"upright(\"phi2\")\")) + ((\" - 1 / 6\") * ((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (sin(\"upright(\"phi2\")\")))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1188) = upright(\"approx\")(((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))), (upright(\"lower\")(((\"upright(\"phi1\")\") * (((sin(\"upright(\"phi2\")\")) + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\" - 1 / 6\") * (sin(\"upright(\"phi2\")\"))) + ((\"1 / 120\") * ((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (sin(\"upright(\"phi2\")\"))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1198) = upright(\"approx\")(((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))), (upright(\"lower\")(((\"upright(\"phi1\")\") * (((sin(\"upright(\"phi2\")\")) + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\" - 1 / 6\") * (sin(\"upright(\"phi2\")\"))) + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\" - 1 / 5040\") * ((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (sin(\"upright(\"phi2\")\"))))) + ((\"1 / 120\") * (sin(\"upright(\"phi2\")\")))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1202) = upright(\"approx\")((cos(\"upright(\"phi1\")\")), (upright(\"lower\")(((\"1 / 1\") + ((\" - 1 / 2\") * ((\"upright(\"phi1\")\")^(\"2 / 1\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1208) = upright(\"approx\")((cos(\"upright(\"phi1\")\")), (upright(\"lower\")(((\"1 / 1\") + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\"1 / 24\") * ((\"upright(\"phi1\")\")^(\"2 / 1\"))) - (\"1 / 2\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1216) = upright(\"approx\")((cos(\"upright(\"phi1\")\")), (upright(\"lower\")(((\"1 / 1\") + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * (((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (((\"1 / 24\") + ((\" - 1 / 720\") * ((\"upright(\"phi1\")\")^(\"2 / 1\")))))) - (\"1 / 2\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1218) = upright(\"approx\")(((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))), (upright(\"lower\")((cos(\"upright(\"phi2\")\")), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1223) = upright(\"approx\")(((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos(\"upright(\"phi2\")\")) + ((\" - 1 / 2\") * ((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (cos(\"upright(\"phi2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1230) = upright(\"approx\")(((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos(\"upright(\"phi2\")\")) + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\" - 1 / 2\") * (cos(\"upright(\"phi2\")\"))) + ((\"1 / 24\") * ((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (cos(\"upright(\"phi2\")\"))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1239) = upright(\"approx\")(((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos(\"upright(\"phi2\")\")) + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\" - 1 / 2\") * (cos(\"upright(\"phi2\")\"))) + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\" - 1 / 720\") * ((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (cos(\"upright(\"phi2\")\"))))) + ((\"1 / 24\") * (cos(\"upright(\"phi2\")\")))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1242) = upright(\"approx\")(((\"upright(\"phi2\")\") * (sin(\"upright(\"phi1\")\"))), (upright(\"lower\")(((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\")), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1248) = upright(\"approx\")(((\"upright(\"phi2\")\") * (sin(\"upright(\"phi1\")\"))), (upright(\"lower\")(((\"upright(\"phi1\")\") * (((\"upright(\"phi2\")\") + ((\" - 1 / 6\") * ((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (\"upright(\"phi2\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1256) = upright(\"approx\")(((\"upright(\"phi2\")\") * (sin(\"upright(\"phi1\")\"))), (upright(\"lower\")(((\"upright(\"phi1\")\") * (((\"upright(\"phi2\")\") + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\" - 1 / 6\") * (\"upright(\"phi2\")\")) + ((\"1 / 120\") * ((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (\"upright(\"phi2\")\")))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1266) = upright(\"approx\")(((\"upright(\"phi2\")\") * (sin(\"upright(\"phi1\")\"))), (upright(\"lower\")(((\"upright(\"phi1\")\") * (((\"upright(\"phi2\")\") + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\" - 1 / 6\") * (\"upright(\"phi2\")\")) + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\" - 1 / 5040\") * ((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (\"upright(\"phi2\")\")))) + ((\"1 / 120\") * (\"upright(\"phi2\")\"))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1268) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")(((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1273) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")((((\" - 1 / 2\") * ((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1280) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")((((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\" - 1 / 2\") * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))) + ((\"1 / 24\") * ((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1289) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")((((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\" - 1 / 2\") * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))) + (((\"upright(\"phi1\")\")^(\"2 / 1\")) * ((((\" - 1 / 720\") * ((((\"upright(\"phi1\")\")^(\"2 / 1\")) * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))))) + ((\"1 / 24\") * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1292) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1299) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((\"upright(\"phi1\")\") * (((sin(\"upright(\"phi2\")\")) + ((\" - 1 / 2\") * (((\"upright(\"phi1\")\") * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))))))))))))) + ((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1308) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((\"upright(\"phi1\")\") * (((sin(\"upright(\"phi2\")\")) + ((\"upright(\"phi1\")\") * ((((\" - 1 / 2\") * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((\" - 1 / 6\") * (((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))))))))))) + ((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1315) = upright(\"approx\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"phi1\")\") * (((sin(\"upright(\"phi2\")\")) + ((\" - 1 / 2\") * (((\"upright(\"phi1\")\") * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))))))))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1322) = upright(\"approx\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"phi1\")\") * (((sin(\"upright(\"phi2\")\")) + ((\"upright(\"phi1\")\") * ((((\" - 1 / 2\") * (((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))) + ((\" - 1 / 6\") * (((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))))))))))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1324) = upright(\"approx\")((sin(\"upright(\"phi1\")\")), (upright(\"lower\")((sin(\"upright(\"phi1\")\")), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1326) = upright(\"approx\")(((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))), (upright(\"lower\")(((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1328) = upright(\"approx\")((cos(\"upright(\"phi1\")\")), (upright(\"lower\")((cos(\"upright(\"phi1\")\")), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1330) = upright(\"approx\")(((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1332) = upright(\"approx\")(((\"upright(\"phi2\")\") * (sin(\"upright(\"phi1\")\"))), (upright(\"lower\")(((\"upright(\"phi2\")\") * (sin(\"upright(\"phi1\")\"))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1337) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((\"upright(\"phi1\")\") * (((\"upright(\"phi2\")\") + (frac(cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))), \"upright(\"phi1\")\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1342) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")(((\"upright(\"phi1\")\") * (((sin(\"upright(\"phi2\")\")) + (frac(((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), \"upright(\"phi1\")\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1348) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")(((\"upright(\"phi1\")\") * (((sin(\"upright(\"phi2\")\")) + ((\"1 / 2\") * ((frac(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"lambda2\")\"))))), \"upright(\"phi1\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1355) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"phi1\")\") * ((((\" - 1 / 1\") * (\"upright(\"phi2\")\")) + ((\" - 1 / 1\") * ((frac(cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))), \"upright(\"phi1\")\"))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1362) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"phi1\")\") * ((((\" - 1 / 1\") * (sin(\"upright(\"phi2\")\"))) + ((\" - 1 / 1\") * ((frac(((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), \"upright(\"phi1\")\"))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1368) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"phi1\")\") * ((((\" - 1 / 1\") * (sin(\"upright(\"phi2\")\"))) + ((\" - 1 / 2\") * ((frac(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + (\"upright(\"phi2\")\")))))) + (sin(((((\"upright(\"lambda1\")\") + (((\"upright(\"phi2\")\") + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"lambda2\")\"))))), \"upright(\"phi1\")\"))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1370) = upright(\"approx\")(\"upright(\"phi2\")\", (upright(\"lower\")(\"upright(\"phi2\")\", \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1376) = upright(\"approx\")((sin(\"upright(\"phi2\")\")), (upright(\"lower\")(((\"upright(\"phi2\")\") * (((\"1 / 1\") + ((\" - 1 / 6\") * ((\"upright(\"phi2\")\")^(\"2 / 1\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1383) = upright(\"approx\")((sin(\"upright(\"phi2\")\")), (upright(\"lower\")(((\"upright(\"phi2\")\") * (((\"1 / 1\") + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\"1 / 120\") * ((\"upright(\"phi2\")\")^(\"2 / 1\"))) - (\"1 / 6\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1392) = upright(\"approx\")((sin(\"upright(\"phi2\")\")), (upright(\"lower\")(((\"upright(\"phi2\")\") * (((\"1 / 1\") + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * (((((\"upright(\"phi2\")\")^(\"2 / 1\")) * (((\"1 / 120\") + ((\" - 1 / 5040\") * ((\"upright(\"phi2\")\")^(\"2 / 1\")))))) - (\"1 / 6\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1398) = upright(\"approx\")(((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))), (upright(\"lower\")(((\"upright(\"phi2\")\") * (((sin(\"upright(\"phi1\")\")) + ((\" - 1 / 6\") * ((((\"upright(\"phi2\")\")^(\"2 / 1\")) * (sin(\"upright(\"phi1\")\")))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1406) = upright(\"approx\")(((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))), (upright(\"lower\")(((\"upright(\"phi2\")\") * (((sin(\"upright(\"phi1\")\")) + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\" - 1 / 6\") * (sin(\"upright(\"phi1\")\"))) + ((\"1 / 120\") * ((((\"upright(\"phi2\")\")^(\"2 / 1\")) * (sin(\"upright(\"phi1\")\"))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1416) = upright(\"approx\")(((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))), (upright(\"lower\")(((\"upright(\"phi2\")\") * (((sin(\"upright(\"phi1\")\")) + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\" - 1 / 6\") * (sin(\"upright(\"phi1\")\"))) + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\" - 1 / 5040\") * ((((\"upright(\"phi2\")\")^(\"2 / 1\")) * (sin(\"upright(\"phi1\")\"))))) + ((\"1 / 120\") * (sin(\"upright(\"phi1\")\")))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1420) = upright(\"approx\")((cos(\"upright(\"phi2\")\")), (upright(\"lower\")(((\"1 / 1\") + ((\" - 1 / 2\") * ((\"upright(\"phi2\")\")^(\"2 / 1\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1426) = upright(\"approx\")((cos(\"upright(\"phi2\")\")), (upright(\"lower\")(((\"1 / 1\") + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\"1 / 24\") * ((\"upright(\"phi2\")\")^(\"2 / 1\"))) - (\"1 / 2\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1434) = upright(\"approx\")((cos(\"upright(\"phi2\")\")), (upright(\"lower\")(((\"1 / 1\") + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * (((((\"upright(\"phi2\")\")^(\"2 / 1\")) * (((\"1 / 24\") + ((\" - 1 / 720\") * ((\"upright(\"phi2\")\")^(\"2 / 1\")))))) - (\"1 / 2\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1439) = upright(\"approx\")(((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos(\"upright(\"phi1\")\")) + ((\" - 1 / 2\") * ((((\"upright(\"phi2\")\")^(\"2 / 1\")) * (cos(\"upright(\"phi1\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1446) = upright(\"approx\")(((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos(\"upright(\"phi1\")\")) + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\" - 1 / 2\") * (cos(\"upright(\"phi1\")\"))) + ((\"1 / 24\") * ((((\"upright(\"phi2\")\")^(\"2 / 1\")) * (cos(\"upright(\"phi1\")\"))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1455) = upright(\"approx\")(((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\"))), (upright(\"lower\")(((cos(\"upright(\"phi1\")\")) + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\" - 1 / 2\") * (cos(\"upright(\"phi1\")\"))) + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\" - 1 / 720\") * ((((\"upright(\"phi2\")\")^(\"2 / 1\")) * (cos(\"upright(\"phi1\")\"))))) + ((\"1 / 24\") * (cos(\"upright(\"phi1\")\")))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1457) = upright(\"approx\")(((\"upright(\"phi2\")\")^(\"2 / 1\")), (upright(\"lower\")(((\"upright(\"phi2\")\")^(\"2 / 1\")), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1459) = upright(\"approx\")(((\" - 1 / 2\") * ((\"upright(\"phi2\")\")^(\"2 / 1\"))), (upright(\"lower\")(((\" - 1 / 2\") * ((\"upright(\"phi2\")\")^(\"2 / 1\"))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1462) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")(((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1467) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")((((\" - 1 / 2\") * ((((\"upright(\"phi2\")\")^(\"2 / 1\")) * (((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))))) + ((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1474) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")((((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\" - 1 / 2\") * (((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))) + ((\"1 / 24\") * ((((\"upright(\"phi2\")\")^(\"2 / 1\")) * (((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1483) = upright(\"approx\")(((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))), (upright(\"lower\")((((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\" - 1 / 2\") * (((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))) + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\" - 1 / 720\") * ((((\"upright(\"phi2\")\")^(\"2 / 1\")) * (((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))))) + ((\"1 / 24\") * (((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1488) = upright(\"approx\")(((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\" - 1 / 2\") * ((((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1496) = upright(\"approx\")(((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))) + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\" - 1 / 2\") * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))) + ((\"1 / 24\") * ((((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1506) = upright(\"approx\")(((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))) + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\" - 1 / 2\") * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))) + (((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((\" - 1 / 720\") * ((((\"upright(\"phi2\")\")^(\"2 / 1\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((\"1 / 24\") * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))))))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1509) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")(((cos(\"upright(\"phi1\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1512) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((\"upright(\"phi2\")\") * (sin(\"upright(\"phi1\")\"))) + ((cos(\"upright(\"phi1\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1519) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((\"upright(\"phi2\")\") * (((sin(\"upright(\"phi1\")\")) + ((\" - 1 / 2\") * (((\"upright(\"phi2\")\") * (((cos(\"upright(\"phi1\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))))))))))))) + ((cos(\"upright(\"phi1\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1528) = upright(\"approx\")((((cos(\"upright(\"phi1\")\")) * (((cos(\"upright(\"phi2\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\")))), (upright(\"lower\")((((\"upright(\"phi2\")\") * (((sin(\"upright(\"phi1\")\")) + ((\"upright(\"phi2\")\") * ((((\" - 1 / 2\") * (((cos(\"upright(\"phi1\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\")))))))) + ((\" - 1 / 6\") * (((\"upright(\"phi2\")\") * (sin(\"upright(\"phi1\")\"))))))))))) + ((cos(\"upright(\"phi1\")\")) * ((((cos(\"upright(\"lambda1\")\")) * (cos(\"upright(\"lambda2\")\"))) + ((sin(\"upright(\"lambda1\")\")) * (sin(\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1535) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi2\")\") * (((\"upright(\"phi1\")\") + ((\" - 1 / 2\") * (((\"upright(\"phi2\")\") * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1544) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + ((cos(\"upright(\"phi2\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi2\")\") * (((\"upright(\"phi1\")\") + ((\"upright(\"phi2\")\") * ((((\" - 1 / 2\") * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + ((\" - 1 / 6\") * (((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1549) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")), (upright(\"lower\")(((((\"upright(\"lambda1\")\") + ((((\" - 1 / 1\") * (\"upright(\"phi2\")\")) + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"lambda2\")\")), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1552) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1558) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (((\"upright(\"phi2\")\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1566) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi2\")\") * ((((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\" - 1 / 2\") * (((\"upright(\"phi2\")\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1575) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi2\")\") * ((((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\"upright(\"phi2\")\") * ((((\" - 1 / 2\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\"1 / 6\") * (((\"upright(\"phi2\")\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1578) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi2\")\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1583) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi2\")\") * (((cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\" - 1 / 2\") * (((\"upright(\"phi2\")\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1591) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi2\")\") * (((cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi2\")\") * ((((\" - 1 / 2\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\" - 1 / 6\") * (((\"upright(\"phi2\")\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1594) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")(((\"2 / 1\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1599) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")((((\"2 / 1\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\"upright(\"phi2\")\") * (((cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1606) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")((((\"2 / 1\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\"upright(\"phi2\")\") * (((cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\" - 1 / 1\") * (((\"upright(\"phi2\")\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1619) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")((((\"2 / 1\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\"upright(\"phi2\")\") * (((cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\"upright(\"phi2\")\") * ((((\" - 1 / 1\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\"upright(\"phi2\")\") * ((((\" - 1 / 6\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\"1 / 6\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1623) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"1 / 2\") * (((\"upright(\"phi2\")\") * (((cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1629) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi2\")\") * ((((\" - 1 / 2\") * (((\"upright(\"phi2\")\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))) + ((\"1 / 2\") * (((cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1637) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi2\")\") * ((((\"1 / 2\") * (((cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))) + ((\"upright(\"phi2\")\") * ((((\" - 1 / 2\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\"1 / 2\") * (((\"upright(\"phi2\")\") * ((((\" - 1 / 6\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\"1 / 6\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1642) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi2\")\") * (((\"upright(\"phi1\")\") + ((\"1 / 2\") * (((cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1647) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi2\")\") * (((\"upright(\"phi1\")\") + ((((\" - 1 / 2\") * (((\"upright(\"phi2\")\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))))) + ((\"1 / 2\") * (((cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1659) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi2\")\") * (((\"upright(\"phi1\")\") + ((((\"1 / 2\") * (((cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))) + ((\" - 1 / 1\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))) + ((\"upright(\"phi2\")\") * ((((\" - 1 / 2\") * (sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\"upright(\"phi2\")\") * ((((\" - 1 / 6\") * (\"upright(\"phi1\")\")) + ((\"1 / 2\") * ((((\" - 1 / 6\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\"))))) + ((\"1 / 6\") * (cos(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")))))))))))))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1662) = upright(\"approx\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"phi2\")\") * (sin(\"upright(\"phi1\")\"))) + ((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1669) = upright(\"approx\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"phi2\")\") * (((sin(\"upright(\"phi1\")\")) + ((\" - 1 / 2\") * (((\"upright(\"phi2\")\") * (((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))))))))) + ((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1676) = upright(\"approx\")((((sin(\"upright(\"phi1\")\")) * (sin(\"upright(\"phi2\")\"))) + ((((cos(\"upright(\"phi1\")\")) * (cos(\"upright(\"phi2\")\")))) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), (upright(\"lower\")((((\"upright(\"phi2\")\") * (((sin(\"upright(\"phi1\")\")) + ((\"upright(\"phi2\")\") * ((((\" - 1 / 2\") * (((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))))) + ((\" - 1 / 6\") * (((\"upright(\"phi2\")\") * (sin(\"upright(\"phi1\")\"))))))))))) + ((cos(\"upright(\"phi1\")\")) * (cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1678) = upright(\"approx\")((sin(\"upright(\"phi2\")\")), (upright(\"lower\")((sin(\"upright(\"phi2\")\")), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1683) = upright(\"approx\")(((\"1 / 1\") + ((\" - 1 / 2\") * ((\"upright(\"phi2\")\")^(\"2 / 1\")))), (upright(\"lower\")((((\"upright(\"phi2\")\")^(\"2 / 1\")) * (((frac(\"1 / 1\", (\"upright(\"phi2\")\")^(\"2 / 1\"))) - (\"1 / 2\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1688) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((\"upright(\"phi2\")\") * (((\"upright(\"phi1\")\") + (frac(cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))), \"upright(\"phi2\")\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1690) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")), (upright(\"lower\")(((\" - 1 / 1\") * (\"upright(\"phi2\")\")), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1700) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")), (upright(\"lower\")(((\"upright(\"phi2\")\") * ((((((\"1 / 2\") * ((frac(upright(\"pi\"), \"upright(\"phi2\")\")))) + (frac(\"upright(\"lambda1\")\", \"upright(\"phi2\")\")))) - (((\"1 / 1\") + (frac(\"upright(\"lambda2\")\", \"upright(\"phi2\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1705) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")), (upright(\"lower\")(((\"upright(\"phi2\")\") * (((((\"1 / 1\") + ((((\"1 / 2\") * ((frac(upright(\"pi\"), \"upright(\"phi2\")\")))) + (frac(\"upright(\"lambda1\")\", \"upright(\"phi2\")\")))))) - (frac(\"upright(\"lambda2\")\", \"upright(\"phi2\")\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1712) = upright(\"approx\")(((cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\")))) + ((\"upright(\"phi1\")\") * (\"upright(\"phi2\")\"))), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"phi2\")\") * ((((\" - 1 / 1\") * (\"upright(\"phi1\")\")) + ((\" - 1 / 1\") * ((frac(cos(((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))), \"upright(\"phi2\")\"))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1719) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"phi2\")\") * (((\"1 / 1\") + ((\" - 1 / 1\") * ((frac(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")), \"upright(\"phi2\")\"))))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1722) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))), (upright(\"lower\")((sin(((((\"upright(\"lambda1\")\") + ((((\" - 1 / 1\") * (\"upright(\"phi2\")\")) + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"lambda2\")\")))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1727) = upright(\"approx\")((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")), (upright(\"lower\")(((\" - 1 / 1\") * (((\"upright(\"phi2\")\") * ((((\" - 1 / 1\") * ((frac(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (\"upright(\"lambda2\")\")), \"upright(\"phi2\")\")))) - (\"1 / 1\")))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1732) = upright(\"approx\")((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\")))), (upright(\"lower\")((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"phi2\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1735) = upright(\"approx\")(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), (upright(\"lower\")(((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"phi2\")\"))))))) + (sin(((((\"upright(\"lambda1\")\") + ((((\" - 1 / 1\") * (\"upright(\"phi2\")\")) + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"lambda2\")\"))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1738) = upright(\"approx\")((frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\")), (upright(\"lower\")(((\"1 / 2\") * (((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"phi2\")\"))))))) + (sin(((((\"upright(\"lambda1\")\") + ((((\" - 1 / 1\") * (\"upright(\"phi2\")\")) + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"lambda2\")\"))))))), \"upright(\"binary64\")\"))) \\ upright(\"to_extract\")(1741) = upright(\"approx\")((((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\"))) + (frac(((sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) - (\"upright(\"phi2\")\")))) + (sin((((((\"1 / 2\") * (upright(\"pi\"))) + (((\"upright(\"lambda1\")\") - (\"upright(\"lambda2\")\"))))) + (\"upright(\"phi2\")\"))))), \"2 / 1\"))), (upright(\"lower\")((((\"1 / 2\") * (((sin(((((\"upright(\"lambda1\")\") + ((\"1 / 2\") * (upright(\"pi\"))))) - (((\"upright(\"lambda2\")\") + ((\" - 1 / 1\") * (\"upright(\"phi2\")\"))))))) + (sin(((((\"upright(\"lambda1\")\") + ((((\" - 1 / 1\") * (\"upright(\"phi2\")\")) + ((\"1 / 2\") * (upright(\"pi\"))))))) - (\"upright(\"lambda2\")\"))))))) + ((\"upright(\"phi1\")\") * (sin(\"upright(\"phi2\")\")))), \"upright(\"binary64\")\")))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"R\" $] $] \\ #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $] \\ #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $] \\ #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $] \\ #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 13 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"0 / 1\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 15 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"R\" $] $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"R\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 34 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"R\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"R\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 52 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) $])) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"R\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"R\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 54 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 58 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 60 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 64 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 70 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 78 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 88 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 90 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 92 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 95 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 101 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 109 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 118 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 720\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 124 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 132 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 142 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 5040\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 145 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 151 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 159 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 169 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 5040\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 171 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 174 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 181 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 190 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 194 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 201 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 209 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 218 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $])) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 221 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 226 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 233 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 242 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 246 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 251 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 258 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 267 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 272 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 276 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 280 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 284 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 289 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 294 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 302 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 311 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) $])) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 317 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 321 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 326 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 329 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 333 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 338 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 345 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 354 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 359 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 363 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 367 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 372 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 379 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 388 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 392 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 398 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 407 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) $])) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 421 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) $])) $])) $]) $])) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 425 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 429 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 436 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 445 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 449 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 452 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 456 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 460 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 463 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 466 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 469 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $])) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 472 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $])) $]) $])) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 474 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 476 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 482 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 484 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 490 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 492 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 494 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 496 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 498 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 500 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 502 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 504 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 506 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 508 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 515 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $])) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 521 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $])) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 524 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 530 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 533 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 536 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 539 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 542 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 544 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 549 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 555 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 561 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $])) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 565 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 568 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 571 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 578 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 585 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 591 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 598 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 602 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 605 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 608 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 611 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 614 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 617 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 620 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"R\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"R\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 622 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 625 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 629 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 637 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 646 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 651 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 657 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 665 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 720\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 670 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 678 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 120\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 688 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 5040\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) $])) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 692 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 698 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 706 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 120\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 716 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 120\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 5040\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $])) $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 718 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 723 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 731 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 741 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 5040\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 744 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 750 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 758 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 763 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 770 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 779 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 5040\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 781 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 787 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 795 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 805 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 5040\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 810 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 815 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 818 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 824 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 831 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 840 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 843 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 847 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 854 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 863 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 866 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 869 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 872 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 875 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 878 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 882 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 886 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 890 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 893 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 896 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 899 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 902 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 904 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 908 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 911 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 914 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 917 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 923 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 931 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 940 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 942 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 946 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 949 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 955 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 963 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 972 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 975 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 981 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 990 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $]) $])) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1004 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $]) $])) $])) $]) $])) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1007 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1011 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1018 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1027 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1030 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1033 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1037 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1041 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]) $])) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1046 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1048 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1050 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1057 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1063 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1069 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1075 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1078 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1081 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1084 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1087 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1090 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1093 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1097 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1100 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1103 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1110 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1117 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1120 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1127 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1130 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1133 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1136 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1139 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1142 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1145 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1148 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"R\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"R\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1150 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1156 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1163 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1172 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 5040\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1174 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1180 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1188 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1198 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 5040\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1202 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1208 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1216 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 720\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1218 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1223 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1230 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1239 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 720\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1242 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1248 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1256 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1266 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 5040\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1268 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1273 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1280 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1289 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 720\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1292 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1299 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1308 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1315 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1322 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1324 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1326 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1328 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1330 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1332 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1337 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1342 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1348 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1355 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $])) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1362 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $])) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1368 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $])) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1370 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $], (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1376 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1383 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1392 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 5040\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1398 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1406 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1416 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 5040\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 120\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1420 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1426 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1434 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 720\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1439 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1446 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1455 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 720\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1457 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1459 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1462 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1467 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1474 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1483 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 720\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1488 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1496 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1506 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 720\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 24\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) $])) $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1509 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1512 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1519 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1528 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $])) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1535 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1544 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1549 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1552 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1558 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1566 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1575 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1578 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1583 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1591 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1594 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1599 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1606 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) $])) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1619 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) $])) $]) $])) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1623 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1629 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1637 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $])) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1642 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1647 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) $])) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1659 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 6\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $])) $]) $])) $]) $])) $]) $])) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1662 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1669 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1676 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 6\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) $])) $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) * (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1678 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1683 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $])^(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1688 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1690 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1700 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1705 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1712 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#B86A5B\"))[$ cos((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $], #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1719 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1722 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1727 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 1\" $] $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1732 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1735 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1738 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $] \\ upright(\"to_extract\")(#text(fill: rgb(\"#B86A5B\"))[$ 1741 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"approx\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ frac((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $])) + (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $])) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"2 / 1\" $] $]) $]) $]), (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lower\")((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) - ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $])) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ sin((#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda1\")\" $] $]) + ((#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \" - 1 / 1\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"1 / 2\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) $]) $])) $])) - (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"lambda2\")\" $] $]) $])) $]) $])) $]) + (#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi1\")\" $] $]) * (#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"phi2\")\" $] $]) $]) $]) $]), #text(fill: rgb(\"#B86A5B\"))[$ \"upright(\"binary64\")\" $]) $])) $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_taylor51_rs__2183_5_MyTxTaylor51_add_rule__t51_lower_var_binary64__bc7166bf4755364a", + "display_name": "t51_lower_var_binary64", + "rule_name": "t51_lower_var_binary64", + "callee": "MyTxTaylor51::add_rule", + "file": "benches/runners/generated/taylor51.rs", + "offset": 149173, + "line": 2183, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 149173, + "end": 149699 + }, + "pattern_range": { + "start": 149257, + "end": 149519 + }, + "action_range": { + "start": 149529, + "end": 149692 + } + }, + "nodes": [ + { + "id": "v", + "kind": "query", + "dsl_type": "T51Var", + "label": "v: T51Var", + "range": { + "start": 149274, + "end": 149298 + }, + "inputs": [] + } + ], + "edges": [], + "roots": [ + "v", + "lower" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@149610:149642", + "bound_var": "out", + "source_text": "ctx.insert_t51_varbinary64(name)", + "semantic_text": null, + "referenced_pat_vars": [ + "v" + ], + "referenced_action_vars": [ + "name" + ], + "range": { + "start": 149610, + "end": 149642 + } + }, + { + "id": "effect_1", + "effect_id": "effect@149656:149681", + "bound_var": null, + "source_text": "ctx.union(pat.lower, out)", + "semantic_text": null, + "referenced_pat_vars": [ + "lower" + ], + "referenced_action_vars": [ + "out" + ], + "range": { + "start": 149656, + "end": 149681 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "T51Var", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Num", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Pi", + "template": "pi", + "fields": [] + }, + { + "variant_name": "T51Neg", + "template": "-({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Sin", + "template": "sin({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Cos", + "template": "cos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Acos", + "template": "acos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Add", + "template": "({a0}) + ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Sub", + "template": "({a0}) - ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Mul", + "template": "({a0}) * ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Div", + "template": "frac({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Pow", + "template": "({a0})^({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Varbinary64", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Numbinary64", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Pif64Ty", + "template": "pi", + "fields": [] + }, + { + "variant_name": "T51Negf64Ty", + "template": "-({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Sinf64Ty", + "template": "sin({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Cosf64Ty", + "template": "cos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Acosf64Ty", + "template": "acos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Addf64Ty", + "template": "({a0}) + ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Subf64Ty", + "template": "({a0}) - ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Mulf64Ty", + "template": "({a0}) * ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Divf64Ty", + "template": "frac({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Powf64Ty", + "template": "({a0})^({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Lower", + "template": "lower({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Approx", + "template": "approx({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "T51Var", + "precedence": 100 + }, + { + "variant_name": "T51Num", + "precedence": 100 + }, + { + "variant_name": "T51Pi", + "precedence": 100 + }, + { + "variant_name": "T51Neg", + "precedence": 70 + }, + { + "variant_name": "T51Sin", + "precedence": 90 + }, + { + "variant_name": "T51Cos", + "precedence": 90 + }, + { + "variant_name": "T51Acos", + "precedence": 90 + }, + { + "variant_name": "T51Add", + "precedence": 50 + }, + { + "variant_name": "T51Sub", + "precedence": 50 + }, + { + "variant_name": "T51Mul", + "precedence": 60 + }, + { + "variant_name": "T51Div", + "precedence": 60 + }, + { + "variant_name": "T51Pow", + "precedence": 80 + }, + { + "variant_name": "T51Varbinary64", + "precedence": 100 + }, + { + "variant_name": "T51Numbinary64", + "precedence": 100 + }, + { + "variant_name": "T51Pif64Ty", + "precedence": 100 + }, + { + "variant_name": "T51Negf64Ty", + "precedence": 70 + }, + { + "variant_name": "T51Sinf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Cosf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Acosf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Addf64Ty", + "precedence": 50 + }, + { + "variant_name": "T51Subf64Ty", + "precedence": 50 + }, + { + "variant_name": "T51Mulf64Ty", + "precedence": 60 + }, + { + "variant_name": "T51Divf64Ty", + "precedence": 60 + }, + { + "variant_name": "T51Powf64Ty", + "precedence": 80 + }, + { + "variant_name": "T51Lower", + "precedence": 90 + }, + { + "variant_name": "T51Approx", + "precedence": 90 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "t51_lower_var_binary64", + "premises": [ + { + "target_id": "v", + "label": "v: T51Var", + "plain_source": "v", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ v $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "out", + "plain_source": "upright(\"name\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ upright(\"name\") $] $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "lower", + "label": "lower", + "plain_source": "upright(\"lower\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "out", + "plain_source": "upright(\"name\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ upright(\"name\") $] $]" + } + } + ], + "formula_source": { + "plain": "frac(v, upright(\"lower\") arrow.r.double upright(\"name\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ v $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ upright(\"name\") $] $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_taylor51_rs__2202_5_MyTxTaylor51_add_rule__t51_lower_num_binary64__47b85d436845cd13", + "display_name": "t51_lower_num_binary64", + "rule_name": "t51_lower_num_binary64", + "callee": "MyTxTaylor51::add_rule", + "file": "benches/runners/generated/taylor51.rs", + "offset": 149706, + "line": 2202, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 149706, + "end": 150226 + }, + "pattern_range": { + "start": 149790, + "end": 150052 + }, + "action_range": { + "start": 150062, + "end": 150219 + } + }, + "nodes": [ + { + "id": "n", + "kind": "query", + "dsl_type": "T51Num", + "label": "n: T51Num", + "range": { + "start": 149807, + "end": 149831 + }, + "inputs": [] + } + ], + "edges": [], + "roots": [ + "n", + "lower" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@150140:150169", + "bound_var": "out", + "source_text": "ctx.insert_t51_numbinary64(v)", + "semantic_text": null, + "referenced_pat_vars": [ + "n" + ], + "referenced_action_vars": [ + "v" + ], + "range": { + "start": 150140, + "end": 150169 + } + }, + { + "id": "effect_1", + "effect_id": "effect@150183:150208", + "bound_var": null, + "source_text": "ctx.union(pat.lower, out)", + "semantic_text": null, + "referenced_pat_vars": [ + "lower" + ], + "referenced_action_vars": [ + "out" + ], + "range": { + "start": 150183, + "end": 150208 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "T51Var", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Num", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Pi", + "template": "pi", + "fields": [] + }, + { + "variant_name": "T51Neg", + "template": "-({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Sin", + "template": "sin({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Cos", + "template": "cos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Acos", + "template": "acos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Add", + "template": "({a0}) + ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Sub", + "template": "({a0}) - ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Mul", + "template": "({a0}) * ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Div", + "template": "frac({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Pow", + "template": "({a0})^({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Varbinary64", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Numbinary64", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Pif64Ty", + "template": "pi", + "fields": [] + }, + { + "variant_name": "T51Negf64Ty", + "template": "-({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Sinf64Ty", + "template": "sin({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Cosf64Ty", + "template": "cos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Acosf64Ty", + "template": "acos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Addf64Ty", + "template": "({a0}) + ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Subf64Ty", + "template": "({a0}) - ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Mulf64Ty", + "template": "({a0}) * ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Divf64Ty", + "template": "frac({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Powf64Ty", + "template": "({a0})^({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Lower", + "template": "lower({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Approx", + "template": "approx({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "T51Var", + "precedence": 100 + }, + { + "variant_name": "T51Num", + "precedence": 100 + }, + { + "variant_name": "T51Pi", + "precedence": 100 + }, + { + "variant_name": "T51Neg", + "precedence": 70 + }, + { + "variant_name": "T51Sin", + "precedence": 90 + }, + { + "variant_name": "T51Cos", + "precedence": 90 + }, + { + "variant_name": "T51Acos", + "precedence": 90 + }, + { + "variant_name": "T51Add", + "precedence": 50 + }, + { + "variant_name": "T51Sub", + "precedence": 50 + }, + { + "variant_name": "T51Mul", + "precedence": 60 + }, + { + "variant_name": "T51Div", + "precedence": 60 + }, + { + "variant_name": "T51Pow", + "precedence": 80 + }, + { + "variant_name": "T51Varbinary64", + "precedence": 100 + }, + { + "variant_name": "T51Numbinary64", + "precedence": 100 + }, + { + "variant_name": "T51Pif64Ty", + "precedence": 100 + }, + { + "variant_name": "T51Negf64Ty", + "precedence": 70 + }, + { + "variant_name": "T51Sinf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Cosf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Acosf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Addf64Ty", + "precedence": 50 + }, + { + "variant_name": "T51Subf64Ty", + "precedence": 50 + }, + { + "variant_name": "T51Mulf64Ty", + "precedence": 60 + }, + { + "variant_name": "T51Divf64Ty", + "precedence": 60 + }, + { + "variant_name": "T51Powf64Ty", + "precedence": 80 + }, + { + "variant_name": "T51Lower", + "precedence": 90 + }, + { + "variant_name": "T51Approx", + "precedence": 90 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "t51_lower_num_binary64", + "premises": [ + { + "target_id": "n", + "label": "n: T51Num", + "plain_source": "n", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ n $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "out", + "plain_source": "v", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ v $] $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "lower", + "label": "lower", + "plain_source": "upright(\"lower\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "out", + "plain_source": "v", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ v $] $]" + } + } + ], + "formula_source": { + "plain": "frac(n, upright(\"lower\") arrow.r.double v) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ n $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ v $] $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_taylor51_rs__2221_5_MyTxTaylor51_add_rule__t51_lower_pi_binary64__27defae839bfc745", + "display_name": "t51_lower_pi_binary64", + "rule_name": "t51_lower_pi_binary64", + "callee": "MyTxTaylor51::add_rule", + "file": "benches/runners/generated/taylor51.rs", + "offset": 150233, + "line": 2221, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 150233, + "end": 150679 + }, + "pattern_range": { + "start": 150316, + "end": 150552 + }, + "action_range": { + "start": 150562, + "end": 150672 + } + }, + "nodes": [ + { + "id": "pi", + "kind": "query", + "dsl_type": "T51Pi", + "label": "pi: T51Pi", + "range": { + "start": 150333, + "end": 150357 + }, + "inputs": [] + } + ], + "edges": [], + "roots": [ + "lower" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@150597:150622", + "bound_var": "out", + "source_text": "ctx.insert_t51_pif64_ty()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 150597, + "end": 150622 + } + }, + { + "id": "effect_1", + "effect_id": "effect@150636:150661", + "bound_var": null, + "source_text": "ctx.union(pat.lower, out)", + "semantic_text": null, + "referenced_pat_vars": [ + "lower" + ], + "referenced_action_vars": [ + "out" + ], + "range": { + "start": 150636, + "end": 150661 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "T51Var", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Num", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Pi", + "template": "pi", + "fields": [] + }, + { + "variant_name": "T51Neg", + "template": "-({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Sin", + "template": "sin({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Cos", + "template": "cos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Acos", + "template": "acos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Add", + "template": "({a0}) + ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Sub", + "template": "({a0}) - ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Mul", + "template": "({a0}) * ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Div", + "template": "frac({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Pow", + "template": "({a0})^({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Varbinary64", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Numbinary64", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Pif64Ty", + "template": "pi", + "fields": [] + }, + { + "variant_name": "T51Negf64Ty", + "template": "-({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Sinf64Ty", + "template": "sin({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Cosf64Ty", + "template": "cos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Acosf64Ty", + "template": "acos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Addf64Ty", + "template": "({a0}) + ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Subf64Ty", + "template": "({a0}) - ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Mulf64Ty", + "template": "({a0}) * ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Divf64Ty", + "template": "frac({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Powf64Ty", + "template": "({a0})^({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Lower", + "template": "lower({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Approx", + "template": "approx({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "T51Var", + "precedence": 100 + }, + { + "variant_name": "T51Num", + "precedence": 100 + }, + { + "variant_name": "T51Pi", + "precedence": 100 + }, + { + "variant_name": "T51Neg", + "precedence": 70 + }, + { + "variant_name": "T51Sin", + "precedence": 90 + }, + { + "variant_name": "T51Cos", + "precedence": 90 + }, + { + "variant_name": "T51Acos", + "precedence": 90 + }, + { + "variant_name": "T51Add", + "precedence": 50 + }, + { + "variant_name": "T51Sub", + "precedence": 50 + }, + { + "variant_name": "T51Mul", + "precedence": 60 + }, + { + "variant_name": "T51Div", + "precedence": 60 + }, + { + "variant_name": "T51Pow", + "precedence": 80 + }, + { + "variant_name": "T51Varbinary64", + "precedence": 100 + }, + { + "variant_name": "T51Numbinary64", + "precedence": 100 + }, + { + "variant_name": "T51Pif64Ty", + "precedence": 100 + }, + { + "variant_name": "T51Negf64Ty", + "precedence": 70 + }, + { + "variant_name": "T51Sinf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Cosf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Acosf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Addf64Ty", + "precedence": 50 + }, + { + "variant_name": "T51Subf64Ty", + "precedence": 50 + }, + { + "variant_name": "T51Mulf64Ty", + "precedence": 60 + }, + { + "variant_name": "T51Divf64Ty", + "precedence": 60 + }, + { + "variant_name": "T51Powf64Ty", + "precedence": 80 + }, + { + "variant_name": "T51Lower", + "precedence": 90 + }, + { + "variant_name": "T51Approx", + "precedence": 90 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "t51_lower_pi_binary64", + "premises": [ + { + "target_id": "lower", + "label": "lower", + "plain_source": "upright(\"lower\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower\") $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "out", + "plain_source": "upright(\"pi\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "lower", + "label": "lower", + "plain_source": "upright(\"lower\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "out", + "plain_source": "upright(\"pi\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"lower\"), upright(\"lower\") arrow.r.double upright(\"pi\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"pi\") $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_taylor51_rs__2238_5_MyTxTaylor51_add_rule__t51_lower_neg_binary64__ae2e5851bca25a28", + "display_name": "t51_lower_neg_binary64", + "rule_name": "t51_lower_neg_binary64", + "callee": "MyTxTaylor51::add_rule", + "file": "benches/runners/generated/taylor51.rs", + "offset": 150686, + "line": 2238, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 150686, + "end": 151298 + }, + "pattern_range": { + "start": 150770, + "end": 151157 + }, + "action_range": { + "start": 151167, + "end": 151291 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "M", + "label": "a: M", + "range": { + "start": 150787, + "end": 150811 + }, + "inputs": [] + }, + { + "id": "e", + "kind": "query", + "dsl_type": "T51Neg", + "label": "e: T51Neg", + "range": { + "start": 150824, + "end": 150850 + }, + "inputs": [ + "a" + ] + } + ], + "edges": [ + { + "from": "e", + "to": "a", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "lower_e", + "lower_a" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@151202:151239", + "bound_var": "out", + "source_text": "ctx.insert_t51_negf64_ty(pat.lower_a)", + "semantic_text": null, + "referenced_pat_vars": [ + "lower_a" + ], + "referenced_action_vars": [], + "range": { + "start": 151202, + "end": 151239 + } + }, + { + "id": "effect_1", + "effect_id": "effect@151253:151280", + "bound_var": null, + "source_text": "ctx.union(pat.lower_e, out)", + "semantic_text": null, + "referenced_pat_vars": [ + "lower_e" + ], + "referenced_action_vars": [ + "out" + ], + "range": { + "start": 151253, + "end": 151280 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "T51Var", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Num", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Pi", + "template": "pi", + "fields": [] + }, + { + "variant_name": "T51Neg", + "template": "-({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Sin", + "template": "sin({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Cos", + "template": "cos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Acos", + "template": "acos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Add", + "template": "({a0}) + ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Sub", + "template": "({a0}) - ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Mul", + "template": "({a0}) * ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Div", + "template": "frac({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Pow", + "template": "({a0})^({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Varbinary64", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Numbinary64", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Pif64Ty", + "template": "pi", + "fields": [] + }, + { + "variant_name": "T51Negf64Ty", + "template": "-({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Sinf64Ty", + "template": "sin({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Cosf64Ty", + "template": "cos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Acosf64Ty", + "template": "acos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Addf64Ty", + "template": "({a0}) + ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Subf64Ty", + "template": "({a0}) - ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Mulf64Ty", + "template": "({a0}) * ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Divf64Ty", + "template": "frac({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Powf64Ty", + "template": "({a0})^({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Lower", + "template": "lower({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Approx", + "template": "approx({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "T51Var", + "precedence": 100 + }, + { + "variant_name": "T51Num", + "precedence": 100 + }, + { + "variant_name": "T51Pi", + "precedence": 100 + }, + { + "variant_name": "T51Neg", + "precedence": 70 + }, + { + "variant_name": "T51Sin", + "precedence": 90 + }, + { + "variant_name": "T51Cos", + "precedence": 90 + }, + { + "variant_name": "T51Acos", + "precedence": 90 + }, + { + "variant_name": "T51Add", + "precedence": 50 + }, + { + "variant_name": "T51Sub", + "precedence": 50 + }, + { + "variant_name": "T51Mul", + "precedence": 60 + }, + { + "variant_name": "T51Div", + "precedence": 60 + }, + { + "variant_name": "T51Pow", + "precedence": 80 + }, + { + "variant_name": "T51Varbinary64", + "precedence": 100 + }, + { + "variant_name": "T51Numbinary64", + "precedence": 100 + }, + { + "variant_name": "T51Pif64Ty", + "precedence": 100 + }, + { + "variant_name": "T51Negf64Ty", + "precedence": 70 + }, + { + "variant_name": "T51Sinf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Cosf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Acosf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Addf64Ty", + "precedence": 50 + }, + { + "variant_name": "T51Subf64Ty", + "precedence": 50 + }, + { + "variant_name": "T51Mulf64Ty", + "precedence": 60 + }, + { + "variant_name": "T51Divf64Ty", + "precedence": 60 + }, + { + "variant_name": "T51Powf64Ty", + "precedence": 80 + }, + { + "variant_name": "T51Lower", + "precedence": 90 + }, + { + "variant_name": "T51Approx", + "precedence": 90 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "t51_lower_neg_binary64", + "premises": [ + { + "target_id": "lower_e", + "label": "lower_e", + "plain_source": "upright(\"lower_e\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $]" + }, + { + "target_id": "lower_a", + "label": "lower_a", + "plain_source": "upright(\"lower_a\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "out", + "plain_source": "-(upright(\"lower_a\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "lower_e", + "label": "lower_e", + "plain_source": "upright(\"lower_e\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "out", + "plain_source": "-(upright(\"lower_a\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"lower_e\") \\ upright(\"lower_a\"), upright(\"lower_e\") arrow.r.double -(upright(\"lower_a\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ -(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]) $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_taylor51_rs__2258_5_MyTxTaylor51_add_rule__t51_lower_sin_binary64__da11de17ddc8d4f2", + "display_name": "t51_lower_sin_binary64", + "rule_name": "t51_lower_sin_binary64", + "callee": "MyTxTaylor51::add_rule", + "file": "benches/runners/generated/taylor51.rs", + "offset": 151305, + "line": 2258, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 151305, + "end": 151917 + }, + "pattern_range": { + "start": 151389, + "end": 151776 + }, + "action_range": { + "start": 151786, + "end": 151910 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "M", + "label": "a: M", + "range": { + "start": 151406, + "end": 151430 + }, + "inputs": [] + }, + { + "id": "e", + "kind": "query", + "dsl_type": "T51Sin", + "label": "e: T51Sin", + "range": { + "start": 151443, + "end": 151469 + }, + "inputs": [ + "a" + ] + } + ], + "edges": [ + { + "from": "e", + "to": "a", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "lower_e", + "lower_a" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@151821:151858", + "bound_var": "out", + "source_text": "ctx.insert_t51_sinf64_ty(pat.lower_a)", + "semantic_text": null, + "referenced_pat_vars": [ + "lower_a" + ], + "referenced_action_vars": [], + "range": { + "start": 151821, + "end": 151858 + } + }, + { + "id": "effect_1", + "effect_id": "effect@151872:151899", + "bound_var": null, + "source_text": "ctx.union(pat.lower_e, out)", + "semantic_text": null, + "referenced_pat_vars": [ + "lower_e" + ], + "referenced_action_vars": [ + "out" + ], + "range": { + "start": 151872, + "end": 151899 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "T51Var", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Num", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Pi", + "template": "pi", + "fields": [] + }, + { + "variant_name": "T51Neg", + "template": "-({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Sin", + "template": "sin({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Cos", + "template": "cos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Acos", + "template": "acos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Add", + "template": "({a0}) + ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Sub", + "template": "({a0}) - ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Mul", + "template": "({a0}) * ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Div", + "template": "frac({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Pow", + "template": "({a0})^({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Varbinary64", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Numbinary64", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Pif64Ty", + "template": "pi", + "fields": [] + }, + { + "variant_name": "T51Negf64Ty", + "template": "-({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Sinf64Ty", + "template": "sin({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Cosf64Ty", + "template": "cos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Acosf64Ty", + "template": "acos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Addf64Ty", + "template": "({a0}) + ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Subf64Ty", + "template": "({a0}) - ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Mulf64Ty", + "template": "({a0}) * ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Divf64Ty", + "template": "frac({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Powf64Ty", + "template": "({a0})^({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Lower", + "template": "lower({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Approx", + "template": "approx({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "T51Var", + "precedence": 100 + }, + { + "variant_name": "T51Num", + "precedence": 100 + }, + { + "variant_name": "T51Pi", + "precedence": 100 + }, + { + "variant_name": "T51Neg", + "precedence": 70 + }, + { + "variant_name": "T51Sin", + "precedence": 90 + }, + { + "variant_name": "T51Cos", + "precedence": 90 + }, + { + "variant_name": "T51Acos", + "precedence": 90 + }, + { + "variant_name": "T51Add", + "precedence": 50 + }, + { + "variant_name": "T51Sub", + "precedence": 50 + }, + { + "variant_name": "T51Mul", + "precedence": 60 + }, + { + "variant_name": "T51Div", + "precedence": 60 + }, + { + "variant_name": "T51Pow", + "precedence": 80 + }, + { + "variant_name": "T51Varbinary64", + "precedence": 100 + }, + { + "variant_name": "T51Numbinary64", + "precedence": 100 + }, + { + "variant_name": "T51Pif64Ty", + "precedence": 100 + }, + { + "variant_name": "T51Negf64Ty", + "precedence": 70 + }, + { + "variant_name": "T51Sinf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Cosf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Acosf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Addf64Ty", + "precedence": 50 + }, + { + "variant_name": "T51Subf64Ty", + "precedence": 50 + }, + { + "variant_name": "T51Mulf64Ty", + "precedence": 60 + }, + { + "variant_name": "T51Divf64Ty", + "precedence": 60 + }, + { + "variant_name": "T51Powf64Ty", + "precedence": 80 + }, + { + "variant_name": "T51Lower", + "precedence": 90 + }, + { + "variant_name": "T51Approx", + "precedence": 90 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "t51_lower_sin_binary64", + "premises": [ + { + "target_id": "lower_e", + "label": "lower_e", + "plain_source": "upright(\"lower_e\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $]" + }, + { + "target_id": "lower_a", + "label": "lower_a", + "plain_source": "upright(\"lower_a\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "out", + "plain_source": "sin(upright(\"lower_a\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "lower_e", + "label": "lower_e", + "plain_source": "upright(\"lower_e\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "out", + "plain_source": "sin(upright(\"lower_a\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"lower_e\") \\ upright(\"lower_a\"), upright(\"lower_e\") arrow.r.double sin(upright(\"lower_a\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ sin(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]) $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_taylor51_rs__2278_5_MyTxTaylor51_add_rule__t51_lower_cos_binary64__4d27313d47a21bab", + "display_name": "t51_lower_cos_binary64", + "rule_name": "t51_lower_cos_binary64", + "callee": "MyTxTaylor51::add_rule", + "file": "benches/runners/generated/taylor51.rs", + "offset": 151924, + "line": 2278, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 151924, + "end": 152536 + }, + "pattern_range": { + "start": 152008, + "end": 152395 + }, + "action_range": { + "start": 152405, + "end": 152529 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "M", + "label": "a: M", + "range": { + "start": 152025, + "end": 152049 + }, + "inputs": [] + }, + { + "id": "e", + "kind": "query", + "dsl_type": "T51Cos", + "label": "e: T51Cos", + "range": { + "start": 152062, + "end": 152088 + }, + "inputs": [ + "a" + ] + } + ], + "edges": [ + { + "from": "e", + "to": "a", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "lower_e", + "lower_a" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@152440:152477", + "bound_var": "out", + "source_text": "ctx.insert_t51_cosf64_ty(pat.lower_a)", + "semantic_text": null, + "referenced_pat_vars": [ + "lower_a" + ], + "referenced_action_vars": [], + "range": { + "start": 152440, + "end": 152477 + } + }, + { + "id": "effect_1", + "effect_id": "effect@152491:152518", + "bound_var": null, + "source_text": "ctx.union(pat.lower_e, out)", + "semantic_text": null, + "referenced_pat_vars": [ + "lower_e" + ], + "referenced_action_vars": [ + "out" + ], + "range": { + "start": 152491, + "end": 152518 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "T51Var", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Num", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Pi", + "template": "pi", + "fields": [] + }, + { + "variant_name": "T51Neg", + "template": "-({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Sin", + "template": "sin({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Cos", + "template": "cos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Acos", + "template": "acos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Add", + "template": "({a0}) + ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Sub", + "template": "({a0}) - ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Mul", + "template": "({a0}) * ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Div", + "template": "frac({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Pow", + "template": "({a0})^({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Varbinary64", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Numbinary64", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Pif64Ty", + "template": "pi", + "fields": [] + }, + { + "variant_name": "T51Negf64Ty", + "template": "-({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Sinf64Ty", + "template": "sin({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Cosf64Ty", + "template": "cos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Acosf64Ty", + "template": "acos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Addf64Ty", + "template": "({a0}) + ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Subf64Ty", + "template": "({a0}) - ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Mulf64Ty", + "template": "({a0}) * ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Divf64Ty", + "template": "frac({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Powf64Ty", + "template": "({a0})^({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Lower", + "template": "lower({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Approx", + "template": "approx({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "T51Var", + "precedence": 100 + }, + { + "variant_name": "T51Num", + "precedence": 100 + }, + { + "variant_name": "T51Pi", + "precedence": 100 + }, + { + "variant_name": "T51Neg", + "precedence": 70 + }, + { + "variant_name": "T51Sin", + "precedence": 90 + }, + { + "variant_name": "T51Cos", + "precedence": 90 + }, + { + "variant_name": "T51Acos", + "precedence": 90 + }, + { + "variant_name": "T51Add", + "precedence": 50 + }, + { + "variant_name": "T51Sub", + "precedence": 50 + }, + { + "variant_name": "T51Mul", + "precedence": 60 + }, + { + "variant_name": "T51Div", + "precedence": 60 + }, + { + "variant_name": "T51Pow", + "precedence": 80 + }, + { + "variant_name": "T51Varbinary64", + "precedence": 100 + }, + { + "variant_name": "T51Numbinary64", + "precedence": 100 + }, + { + "variant_name": "T51Pif64Ty", + "precedence": 100 + }, + { + "variant_name": "T51Negf64Ty", + "precedence": 70 + }, + { + "variant_name": "T51Sinf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Cosf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Acosf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Addf64Ty", + "precedence": 50 + }, + { + "variant_name": "T51Subf64Ty", + "precedence": 50 + }, + { + "variant_name": "T51Mulf64Ty", + "precedence": 60 + }, + { + "variant_name": "T51Divf64Ty", + "precedence": 60 + }, + { + "variant_name": "T51Powf64Ty", + "precedence": 80 + }, + { + "variant_name": "T51Lower", + "precedence": 90 + }, + { + "variant_name": "T51Approx", + "precedence": 90 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "t51_lower_cos_binary64", + "premises": [ + { + "target_id": "lower_e", + "label": "lower_e", + "plain_source": "upright(\"lower_e\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $]" + }, + { + "target_id": "lower_a", + "label": "lower_a", + "plain_source": "upright(\"lower_a\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "out", + "plain_source": "cos(upright(\"lower_a\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "lower_e", + "label": "lower_e", + "plain_source": "upright(\"lower_e\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "out", + "plain_source": "cos(upright(\"lower_a\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"lower_e\") \\ upright(\"lower_a\"), upright(\"lower_e\") arrow.r.double cos(upright(\"lower_a\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ cos(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]) $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_taylor51_rs__2298_5_MyTxTaylor51_add_rule__t51_lower_acos_binary64__71971eb85bc7fc06", + "display_name": "t51_lower_acos_binary64", + "rule_name": "t51_lower_acos_binary64", + "callee": "MyTxTaylor51::add_rule", + "file": "benches/runners/generated/taylor51.rs", + "offset": 152543, + "line": 2298, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 152543, + "end": 153158 + }, + "pattern_range": { + "start": 152628, + "end": 153016 + }, + "action_range": { + "start": 153026, + "end": 153151 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "M", + "label": "a: M", + "range": { + "start": 152645, + "end": 152669 + }, + "inputs": [] + }, + { + "id": "e", + "kind": "query", + "dsl_type": "T51Acos", + "label": "e: T51Acos", + "range": { + "start": 152682, + "end": 152709 + }, + "inputs": [ + "a" + ] + } + ], + "edges": [ + { + "from": "e", + "to": "a", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "lower_e", + "lower_a" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@153061:153099", + "bound_var": "out", + "source_text": "ctx.insert_t51_acosf64_ty(pat.lower_a)", + "semantic_text": null, + "referenced_pat_vars": [ + "lower_a" + ], + "referenced_action_vars": [], + "range": { + "start": 153061, + "end": 153099 + } + }, + { + "id": "effect_1", + "effect_id": "effect@153113:153140", + "bound_var": null, + "source_text": "ctx.union(pat.lower_e, out)", + "semantic_text": null, + "referenced_pat_vars": [ + "lower_e" + ], + "referenced_action_vars": [ + "out" + ], + "range": { + "start": 153113, + "end": 153140 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "T51Var", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Num", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Pi", + "template": "pi", + "fields": [] + }, + { + "variant_name": "T51Neg", + "template": "-({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Sin", + "template": "sin({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Cos", + "template": "cos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Acos", + "template": "acos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Add", + "template": "({a0}) + ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Sub", + "template": "({a0}) - ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Mul", + "template": "({a0}) * ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Div", + "template": "frac({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Pow", + "template": "({a0})^({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Varbinary64", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Numbinary64", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Pif64Ty", + "template": "pi", + "fields": [] + }, + { + "variant_name": "T51Negf64Ty", + "template": "-({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Sinf64Ty", + "template": "sin({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Cosf64Ty", + "template": "cos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Acosf64Ty", + "template": "acos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Addf64Ty", + "template": "({a0}) + ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Subf64Ty", + "template": "({a0}) - ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Mulf64Ty", + "template": "({a0}) * ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Divf64Ty", + "template": "frac({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Powf64Ty", + "template": "({a0})^({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Lower", + "template": "lower({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Approx", + "template": "approx({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "T51Var", + "precedence": 100 + }, + { + "variant_name": "T51Num", + "precedence": 100 + }, + { + "variant_name": "T51Pi", + "precedence": 100 + }, + { + "variant_name": "T51Neg", + "precedence": 70 + }, + { + "variant_name": "T51Sin", + "precedence": 90 + }, + { + "variant_name": "T51Cos", + "precedence": 90 + }, + { + "variant_name": "T51Acos", + "precedence": 90 + }, + { + "variant_name": "T51Add", + "precedence": 50 + }, + { + "variant_name": "T51Sub", + "precedence": 50 + }, + { + "variant_name": "T51Mul", + "precedence": 60 + }, + { + "variant_name": "T51Div", + "precedence": 60 + }, + { + "variant_name": "T51Pow", + "precedence": 80 + }, + { + "variant_name": "T51Varbinary64", + "precedence": 100 + }, + { + "variant_name": "T51Numbinary64", + "precedence": 100 + }, + { + "variant_name": "T51Pif64Ty", + "precedence": 100 + }, + { + "variant_name": "T51Negf64Ty", + "precedence": 70 + }, + { + "variant_name": "T51Sinf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Cosf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Acosf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Addf64Ty", + "precedence": 50 + }, + { + "variant_name": "T51Subf64Ty", + "precedence": 50 + }, + { + "variant_name": "T51Mulf64Ty", + "precedence": 60 + }, + { + "variant_name": "T51Divf64Ty", + "precedence": 60 + }, + { + "variant_name": "T51Powf64Ty", + "precedence": 80 + }, + { + "variant_name": "T51Lower", + "precedence": 90 + }, + { + "variant_name": "T51Approx", + "precedence": 90 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "t51_lower_acos_binary64", + "premises": [ + { + "target_id": "lower_e", + "label": "lower_e", + "plain_source": "upright(\"lower_e\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $]" + }, + { + "target_id": "lower_a", + "label": "lower_a", + "plain_source": "upright(\"lower_a\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "out", + "plain_source": "upright(\"acos\")(upright(\"lower_a\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "lower_e", + "label": "lower_e", + "plain_source": "upright(\"lower_e\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "out", + "plain_source": "upright(\"acos\")(upright(\"lower_a\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"lower_e\") \\ upright(\"lower_a\"), upright(\"lower_e\") arrow.r.double upright(\"acos\")(upright(\"lower_a\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"acos\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]) $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_taylor51_rs__2318_5_MyTxTaylor51_add_rule__t51_lower_add_binary64__c294c92e823536b2", + "display_name": "t51_lower_add_binary64", + "rule_name": "t51_lower_add_binary64", + "callee": "MyTxTaylor51::add_rule", + "file": "benches/runners/generated/taylor51.rs", + "offset": 153165, + "line": 2318, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 153165, + "end": 153940 + }, + "pattern_range": { + "start": 153249, + "end": 153786 + }, + "action_range": { + "start": 153796, + "end": 153933 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "M", + "label": "a: M", + "range": { + "start": 153266, + "end": 153290 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "M", + "label": "b: M", + "range": { + "start": 153303, + "end": 153327 + }, + "inputs": [] + }, + { + "id": "e", + "kind": "query", + "dsl_type": "T51Add", + "label": "e: T51Add", + "range": { + "start": 153340, + "end": 153370 + }, + "inputs": [ + "a", + "b" + ] + } + ], + "edges": [ + { + "from": "e", + "to": "a", + "kind": "operand", + "index": 0 + }, + { + "from": "e", + "to": "b", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "lower_e", + "lower_a", + "lower_b" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@153831:153881", + "bound_var": "out", + "source_text": "ctx.insert_t51_addf64_ty(pat.lower_a, pat.lower_b)", + "semantic_text": null, + "referenced_pat_vars": [ + "lower_a", + "lower_b" + ], + "referenced_action_vars": [], + "range": { + "start": 153831, + "end": 153881 + } + }, + { + "id": "effect_1", + "effect_id": "effect@153895:153922", + "bound_var": null, + "source_text": "ctx.union(pat.lower_e, out)", + "semantic_text": null, + "referenced_pat_vars": [ + "lower_e" + ], + "referenced_action_vars": [ + "out" + ], + "range": { + "start": 153895, + "end": 153922 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "T51Var", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Num", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Pi", + "template": "pi", + "fields": [] + }, + { + "variant_name": "T51Neg", + "template": "-({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Sin", + "template": "sin({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Cos", + "template": "cos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Acos", + "template": "acos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Add", + "template": "({a0}) + ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Sub", + "template": "({a0}) - ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Mul", + "template": "({a0}) * ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Div", + "template": "frac({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Pow", + "template": "({a0})^({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Varbinary64", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Numbinary64", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Pif64Ty", + "template": "pi", + "fields": [] + }, + { + "variant_name": "T51Negf64Ty", + "template": "-({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Sinf64Ty", + "template": "sin({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Cosf64Ty", + "template": "cos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Acosf64Ty", + "template": "acos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Addf64Ty", + "template": "({a0}) + ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Subf64Ty", + "template": "({a0}) - ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Mulf64Ty", + "template": "({a0}) * ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Divf64Ty", + "template": "frac({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Powf64Ty", + "template": "({a0})^({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Lower", + "template": "lower({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Approx", + "template": "approx({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "T51Var", + "precedence": 100 + }, + { + "variant_name": "T51Num", + "precedence": 100 + }, + { + "variant_name": "T51Pi", + "precedence": 100 + }, + { + "variant_name": "T51Neg", + "precedence": 70 + }, + { + "variant_name": "T51Sin", + "precedence": 90 + }, + { + "variant_name": "T51Cos", + "precedence": 90 + }, + { + "variant_name": "T51Acos", + "precedence": 90 + }, + { + "variant_name": "T51Add", + "precedence": 50 + }, + { + "variant_name": "T51Sub", + "precedence": 50 + }, + { + "variant_name": "T51Mul", + "precedence": 60 + }, + { + "variant_name": "T51Div", + "precedence": 60 + }, + { + "variant_name": "T51Pow", + "precedence": 80 + }, + { + "variant_name": "T51Varbinary64", + "precedence": 100 + }, + { + "variant_name": "T51Numbinary64", + "precedence": 100 + }, + { + "variant_name": "T51Pif64Ty", + "precedence": 100 + }, + { + "variant_name": "T51Negf64Ty", + "precedence": 70 + }, + { + "variant_name": "T51Sinf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Cosf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Acosf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Addf64Ty", + "precedence": 50 + }, + { + "variant_name": "T51Subf64Ty", + "precedence": 50 + }, + { + "variant_name": "T51Mulf64Ty", + "precedence": 60 + }, + { + "variant_name": "T51Divf64Ty", + "precedence": 60 + }, + { + "variant_name": "T51Powf64Ty", + "precedence": 80 + }, + { + "variant_name": "T51Lower", + "precedence": 90 + }, + { + "variant_name": "T51Approx", + "precedence": 90 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "t51_lower_add_binary64", + "premises": [ + { + "target_id": "lower_e", + "label": "lower_e", + "plain_source": "upright(\"lower_e\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $]" + }, + { + "target_id": "lower_a", + "label": "lower_a", + "plain_source": "upright(\"lower_a\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]" + }, + { + "target_id": "lower_b", + "label": "lower_b", + "plain_source": "upright(\"lower_b\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_b\") $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "out", + "plain_source": "(upright(\"lower_a\")) + (upright(\"lower_b\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]) + (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_b\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "lower_e", + "label": "lower_e", + "plain_source": "upright(\"lower_e\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "out", + "plain_source": "(upright(\"lower_a\")) + (upright(\"lower_b\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]) + (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_b\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"lower_e\") \\ upright(\"lower_a\") \\ upright(\"lower_b\"), upright(\"lower_e\") arrow.r.double (upright(\"lower_a\")) + (upright(\"lower_b\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_b\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]) + (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_b\") $]) $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_taylor51_rs__2341_5_MyTxTaylor51_add_rule__t51_lower_sub_binary64__ea00b3aa96b78e5f", + "display_name": "t51_lower_sub_binary64", + "rule_name": "t51_lower_sub_binary64", + "callee": "MyTxTaylor51::add_rule", + "file": "benches/runners/generated/taylor51.rs", + "offset": 153947, + "line": 2341, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 153947, + "end": 154722 + }, + "pattern_range": { + "start": 154031, + "end": 154568 + }, + "action_range": { + "start": 154578, + "end": 154715 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "M", + "label": "a: M", + "range": { + "start": 154048, + "end": 154072 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "M", + "label": "b: M", + "range": { + "start": 154085, + "end": 154109 + }, + "inputs": [] + }, + { + "id": "e", + "kind": "query", + "dsl_type": "T51Sub", + "label": "e: T51Sub", + "range": { + "start": 154122, + "end": 154152 + }, + "inputs": [ + "a", + "b" + ] + } + ], + "edges": [ + { + "from": "e", + "to": "a", + "kind": "operand", + "index": 0 + }, + { + "from": "e", + "to": "b", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "lower_e", + "lower_a", + "lower_b" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@154613:154663", + "bound_var": "out", + "source_text": "ctx.insert_t51_subf64_ty(pat.lower_a, pat.lower_b)", + "semantic_text": null, + "referenced_pat_vars": [ + "lower_a", + "lower_b" + ], + "referenced_action_vars": [], + "range": { + "start": 154613, + "end": 154663 + } + }, + { + "id": "effect_1", + "effect_id": "effect@154677:154704", + "bound_var": null, + "source_text": "ctx.union(pat.lower_e, out)", + "semantic_text": null, + "referenced_pat_vars": [ + "lower_e" + ], + "referenced_action_vars": [ + "out" + ], + "range": { + "start": 154677, + "end": 154704 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "T51Var", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Num", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Pi", + "template": "pi", + "fields": [] + }, + { + "variant_name": "T51Neg", + "template": "-({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Sin", + "template": "sin({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Cos", + "template": "cos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Acos", + "template": "acos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Add", + "template": "({a0}) + ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Sub", + "template": "({a0}) - ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Mul", + "template": "({a0}) * ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Div", + "template": "frac({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Pow", + "template": "({a0})^({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Varbinary64", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Numbinary64", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Pif64Ty", + "template": "pi", + "fields": [] + }, + { + "variant_name": "T51Negf64Ty", + "template": "-({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Sinf64Ty", + "template": "sin({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Cosf64Ty", + "template": "cos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Acosf64Ty", + "template": "acos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Addf64Ty", + "template": "({a0}) + ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Subf64Ty", + "template": "({a0}) - ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Mulf64Ty", + "template": "({a0}) * ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Divf64Ty", + "template": "frac({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Powf64Ty", + "template": "({a0})^({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Lower", + "template": "lower({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Approx", + "template": "approx({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "T51Var", + "precedence": 100 + }, + { + "variant_name": "T51Num", + "precedence": 100 + }, + { + "variant_name": "T51Pi", + "precedence": 100 + }, + { + "variant_name": "T51Neg", + "precedence": 70 + }, + { + "variant_name": "T51Sin", + "precedence": 90 + }, + { + "variant_name": "T51Cos", + "precedence": 90 + }, + { + "variant_name": "T51Acos", + "precedence": 90 + }, + { + "variant_name": "T51Add", + "precedence": 50 + }, + { + "variant_name": "T51Sub", + "precedence": 50 + }, + { + "variant_name": "T51Mul", + "precedence": 60 + }, + { + "variant_name": "T51Div", + "precedence": 60 + }, + { + "variant_name": "T51Pow", + "precedence": 80 + }, + { + "variant_name": "T51Varbinary64", + "precedence": 100 + }, + { + "variant_name": "T51Numbinary64", + "precedence": 100 + }, + { + "variant_name": "T51Pif64Ty", + "precedence": 100 + }, + { + "variant_name": "T51Negf64Ty", + "precedence": 70 + }, + { + "variant_name": "T51Sinf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Cosf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Acosf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Addf64Ty", + "precedence": 50 + }, + { + "variant_name": "T51Subf64Ty", + "precedence": 50 + }, + { + "variant_name": "T51Mulf64Ty", + "precedence": 60 + }, + { + "variant_name": "T51Divf64Ty", + "precedence": 60 + }, + { + "variant_name": "T51Powf64Ty", + "precedence": 80 + }, + { + "variant_name": "T51Lower", + "precedence": 90 + }, + { + "variant_name": "T51Approx", + "precedence": 90 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "t51_lower_sub_binary64", + "premises": [ + { + "target_id": "lower_e", + "label": "lower_e", + "plain_source": "upright(\"lower_e\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $]" + }, + { + "target_id": "lower_a", + "label": "lower_a", + "plain_source": "upright(\"lower_a\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]" + }, + { + "target_id": "lower_b", + "label": "lower_b", + "plain_source": "upright(\"lower_b\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_b\") $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "out", + "plain_source": "(upright(\"lower_a\")) - (upright(\"lower_b\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]) - (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_b\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "lower_e", + "label": "lower_e", + "plain_source": "upright(\"lower_e\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "out", + "plain_source": "(upright(\"lower_a\")) - (upright(\"lower_b\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]) - (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_b\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"lower_e\") \\ upright(\"lower_a\") \\ upright(\"lower_b\"), upright(\"lower_e\") arrow.r.double (upright(\"lower_a\")) - (upright(\"lower_b\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_b\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]) - (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_b\") $]) $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_taylor51_rs__2364_5_MyTxTaylor51_add_rule__t51_lower_mul_binary64__e6b46e8c0ea6ebee", + "display_name": "t51_lower_mul_binary64", + "rule_name": "t51_lower_mul_binary64", + "callee": "MyTxTaylor51::add_rule", + "file": "benches/runners/generated/taylor51.rs", + "offset": 154729, + "line": 2364, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 154729, + "end": 155504 + }, + "pattern_range": { + "start": 154813, + "end": 155350 + }, + "action_range": { + "start": 155360, + "end": 155497 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "M", + "label": "a: M", + "range": { + "start": 154830, + "end": 154854 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "M", + "label": "b: M", + "range": { + "start": 154867, + "end": 154891 + }, + "inputs": [] + }, + { + "id": "e", + "kind": "query", + "dsl_type": "T51Mul", + "label": "e: T51Mul", + "range": { + "start": 154904, + "end": 154934 + }, + "inputs": [ + "a", + "b" + ] + } + ], + "edges": [ + { + "from": "e", + "to": "a", + "kind": "operand", + "index": 0 + }, + { + "from": "e", + "to": "b", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "lower_e", + "lower_a", + "lower_b" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@155395:155445", + "bound_var": "out", + "source_text": "ctx.insert_t51_mulf64_ty(pat.lower_a, pat.lower_b)", + "semantic_text": null, + "referenced_pat_vars": [ + "lower_a", + "lower_b" + ], + "referenced_action_vars": [], + "range": { + "start": 155395, + "end": 155445 + } + }, + { + "id": "effect_1", + "effect_id": "effect@155459:155486", + "bound_var": null, + "source_text": "ctx.union(pat.lower_e, out)", + "semantic_text": null, + "referenced_pat_vars": [ + "lower_e" + ], + "referenced_action_vars": [ + "out" + ], + "range": { + "start": 155459, + "end": 155486 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "T51Var", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Num", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Pi", + "template": "pi", + "fields": [] + }, + { + "variant_name": "T51Neg", + "template": "-({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Sin", + "template": "sin({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Cos", + "template": "cos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Acos", + "template": "acos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Add", + "template": "({a0}) + ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Sub", + "template": "({a0}) - ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Mul", + "template": "({a0}) * ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Div", + "template": "frac({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Pow", + "template": "({a0})^({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Varbinary64", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Numbinary64", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Pif64Ty", + "template": "pi", + "fields": [] + }, + { + "variant_name": "T51Negf64Ty", + "template": "-({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Sinf64Ty", + "template": "sin({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Cosf64Ty", + "template": "cos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Acosf64Ty", + "template": "acos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Addf64Ty", + "template": "({a0}) + ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Subf64Ty", + "template": "({a0}) - ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Mulf64Ty", + "template": "({a0}) * ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Divf64Ty", + "template": "frac({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Powf64Ty", + "template": "({a0})^({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Lower", + "template": "lower({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Approx", + "template": "approx({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "T51Var", + "precedence": 100 + }, + { + "variant_name": "T51Num", + "precedence": 100 + }, + { + "variant_name": "T51Pi", + "precedence": 100 + }, + { + "variant_name": "T51Neg", + "precedence": 70 + }, + { + "variant_name": "T51Sin", + "precedence": 90 + }, + { + "variant_name": "T51Cos", + "precedence": 90 + }, + { + "variant_name": "T51Acos", + "precedence": 90 + }, + { + "variant_name": "T51Add", + "precedence": 50 + }, + { + "variant_name": "T51Sub", + "precedence": 50 + }, + { + "variant_name": "T51Mul", + "precedence": 60 + }, + { + "variant_name": "T51Div", + "precedence": 60 + }, + { + "variant_name": "T51Pow", + "precedence": 80 + }, + { + "variant_name": "T51Varbinary64", + "precedence": 100 + }, + { + "variant_name": "T51Numbinary64", + "precedence": 100 + }, + { + "variant_name": "T51Pif64Ty", + "precedence": 100 + }, + { + "variant_name": "T51Negf64Ty", + "precedence": 70 + }, + { + "variant_name": "T51Sinf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Cosf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Acosf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Addf64Ty", + "precedence": 50 + }, + { + "variant_name": "T51Subf64Ty", + "precedence": 50 + }, + { + "variant_name": "T51Mulf64Ty", + "precedence": 60 + }, + { + "variant_name": "T51Divf64Ty", + "precedence": 60 + }, + { + "variant_name": "T51Powf64Ty", + "precedence": 80 + }, + { + "variant_name": "T51Lower", + "precedence": 90 + }, + { + "variant_name": "T51Approx", + "precedence": 90 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "t51_lower_mul_binary64", + "premises": [ + { + "target_id": "lower_e", + "label": "lower_e", + "plain_source": "upright(\"lower_e\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $]" + }, + { + "target_id": "lower_a", + "label": "lower_a", + "plain_source": "upright(\"lower_a\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]" + }, + { + "target_id": "lower_b", + "label": "lower_b", + "plain_source": "upright(\"lower_b\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_b\") $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "out", + "plain_source": "(upright(\"lower_a\")) * (upright(\"lower_b\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]) * (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_b\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "lower_e", + "label": "lower_e", + "plain_source": "upright(\"lower_e\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "out", + "plain_source": "(upright(\"lower_a\")) * (upright(\"lower_b\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]) * (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_b\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"lower_e\") \\ upright(\"lower_a\") \\ upright(\"lower_b\"), upright(\"lower_e\") arrow.r.double (upright(\"lower_a\")) * (upright(\"lower_b\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_b\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]) * (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_b\") $]) $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_taylor51_rs__2387_5_MyTxTaylor51_add_rule__t51_lower_div_binary64__a7df260294a1480a", + "display_name": "t51_lower_div_binary64", + "rule_name": "t51_lower_div_binary64", + "callee": "MyTxTaylor51::add_rule", + "file": "benches/runners/generated/taylor51.rs", + "offset": 155511, + "line": 2387, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 155511, + "end": 156286 + }, + "pattern_range": { + "start": 155595, + "end": 156132 + }, + "action_range": { + "start": 156142, + "end": 156279 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "M", + "label": "a: M", + "range": { + "start": 155612, + "end": 155636 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "M", + "label": "b: M", + "range": { + "start": 155649, + "end": 155673 + }, + "inputs": [] + }, + { + "id": "e", + "kind": "query", + "dsl_type": "T51Div", + "label": "e: T51Div", + "range": { + "start": 155686, + "end": 155716 + }, + "inputs": [ + "a", + "b" + ] + } + ], + "edges": [ + { + "from": "e", + "to": "a", + "kind": "operand", + "index": 0 + }, + { + "from": "e", + "to": "b", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "lower_e", + "lower_a", + "lower_b" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@156177:156227", + "bound_var": "out", + "source_text": "ctx.insert_t51_divf64_ty(pat.lower_a, pat.lower_b)", + "semantic_text": null, + "referenced_pat_vars": [ + "lower_a", + "lower_b" + ], + "referenced_action_vars": [], + "range": { + "start": 156177, + "end": 156227 + } + }, + { + "id": "effect_1", + "effect_id": "effect@156241:156268", + "bound_var": null, + "source_text": "ctx.union(pat.lower_e, out)", + "semantic_text": null, + "referenced_pat_vars": [ + "lower_e" + ], + "referenced_action_vars": [ + "out" + ], + "range": { + "start": 156241, + "end": 156268 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "T51Var", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Num", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Pi", + "template": "pi", + "fields": [] + }, + { + "variant_name": "T51Neg", + "template": "-({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Sin", + "template": "sin({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Cos", + "template": "cos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Acos", + "template": "acos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Add", + "template": "({a0}) + ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Sub", + "template": "({a0}) - ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Mul", + "template": "({a0}) * ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Div", + "template": "frac({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Pow", + "template": "({a0})^({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Varbinary64", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Numbinary64", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Pif64Ty", + "template": "pi", + "fields": [] + }, + { + "variant_name": "T51Negf64Ty", + "template": "-({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Sinf64Ty", + "template": "sin({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Cosf64Ty", + "template": "cos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Acosf64Ty", + "template": "acos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Addf64Ty", + "template": "({a0}) + ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Subf64Ty", + "template": "({a0}) - ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Mulf64Ty", + "template": "({a0}) * ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Divf64Ty", + "template": "frac({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Powf64Ty", + "template": "({a0})^({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Lower", + "template": "lower({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Approx", + "template": "approx({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "T51Var", + "precedence": 100 + }, + { + "variant_name": "T51Num", + "precedence": 100 + }, + { + "variant_name": "T51Pi", + "precedence": 100 + }, + { + "variant_name": "T51Neg", + "precedence": 70 + }, + { + "variant_name": "T51Sin", + "precedence": 90 + }, + { + "variant_name": "T51Cos", + "precedence": 90 + }, + { + "variant_name": "T51Acos", + "precedence": 90 + }, + { + "variant_name": "T51Add", + "precedence": 50 + }, + { + "variant_name": "T51Sub", + "precedence": 50 + }, + { + "variant_name": "T51Mul", + "precedence": 60 + }, + { + "variant_name": "T51Div", + "precedence": 60 + }, + { + "variant_name": "T51Pow", + "precedence": 80 + }, + { + "variant_name": "T51Varbinary64", + "precedence": 100 + }, + { + "variant_name": "T51Numbinary64", + "precedence": 100 + }, + { + "variant_name": "T51Pif64Ty", + "precedence": 100 + }, + { + "variant_name": "T51Negf64Ty", + "precedence": 70 + }, + { + "variant_name": "T51Sinf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Cosf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Acosf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Addf64Ty", + "precedence": 50 + }, + { + "variant_name": "T51Subf64Ty", + "precedence": 50 + }, + { + "variant_name": "T51Mulf64Ty", + "precedence": 60 + }, + { + "variant_name": "T51Divf64Ty", + "precedence": 60 + }, + { + "variant_name": "T51Powf64Ty", + "precedence": 80 + }, + { + "variant_name": "T51Lower", + "precedence": 90 + }, + { + "variant_name": "T51Approx", + "precedence": 90 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "t51_lower_div_binary64", + "premises": [ + { + "target_id": "lower_e", + "label": "lower_e", + "plain_source": "upright(\"lower_e\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $]" + }, + { + "target_id": "lower_a", + "label": "lower_a", + "plain_source": "upright(\"lower_a\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]" + }, + { + "target_id": "lower_b", + "label": "lower_b", + "plain_source": "upright(\"lower_b\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_b\") $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "out", + "plain_source": "frac(upright(\"lower_a\"), upright(\"lower_b\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_b\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "lower_e", + "label": "lower_e", + "plain_source": "upright(\"lower_e\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "out", + "plain_source": "frac(upright(\"lower_a\"), upright(\"lower_b\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_b\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"lower_e\") \\ upright(\"lower_a\") \\ upright(\"lower_b\"), upright(\"lower_e\") arrow.r.double frac(upright(\"lower_a\"), upright(\"lower_b\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_b\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_b\") $]) $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "benches_runners_generated_taylor51_rs__2410_5_MyTxTaylor51_add_rule__t51_lower_pow_binary64__36230516e3752130", + "display_name": "t51_lower_pow_binary64", + "rule_name": "t51_lower_pow_binary64", + "callee": "MyTxTaylor51::add_rule", + "file": "benches/runners/generated/taylor51.rs", + "offset": 156293, + "line": 2410, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 156293, + "end": 157068 + }, + "pattern_range": { + "start": 156377, + "end": 156914 + }, + "action_range": { + "start": 156924, + "end": 157061 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "M", + "label": "a: M", + "range": { + "start": 156394, + "end": 156418 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "M", + "label": "b: M", + "range": { + "start": 156431, + "end": 156455 + }, + "inputs": [] + }, + { + "id": "e", + "kind": "query", + "dsl_type": "T51Pow", + "label": "e: T51Pow", + "range": { + "start": 156468, + "end": 156498 + }, + "inputs": [ + "a", + "b" + ] + } + ], + "edges": [ + { + "from": "e", + "to": "a", + "kind": "operand", + "index": 0 + }, + { + "from": "e", + "to": "b", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "lower_e", + "lower_a", + "lower_b" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@156959:157009", + "bound_var": "out", + "source_text": "ctx.insert_t51_powf64_ty(pat.lower_a, pat.lower_b)", + "semantic_text": null, + "referenced_pat_vars": [ + "lower_a", + "lower_b" + ], + "referenced_action_vars": [], + "range": { + "start": 156959, + "end": 157009 + } + }, + { + "id": "effect_1", + "effect_id": "effect@157023:157050", + "bound_var": null, + "source_text": "ctx.union(pat.lower_e, out)", + "semantic_text": null, + "referenced_pat_vars": [ + "lower_e" + ], + "referenced_action_vars": [ + "out" + ], + "range": { + "start": 157023, + "end": 157050 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "T51Var", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Num", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Pi", + "template": "pi", + "fields": [] + }, + { + "variant_name": "T51Neg", + "template": "-({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Sin", + "template": "sin({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Cos", + "template": "cos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Acos", + "template": "acos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Add", + "template": "({a0}) + ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Sub", + "template": "({a0}) - ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Mul", + "template": "({a0}) * ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Div", + "template": "frac({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Pow", + "template": "({a0})^({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Varbinary64", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Numbinary64", + "template": "{a0}", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Pif64Ty", + "template": "pi", + "fields": [] + }, + { + "variant_name": "T51Negf64Ty", + "template": "-({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Sinf64Ty", + "template": "sin({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Cosf64Ty", + "template": "cos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Acosf64Ty", + "template": "acos({a0})", + "fields": [ + "a0" + ] + }, + { + "variant_name": "T51Addf64Ty", + "template": "({a0}) + ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Subf64Ty", + "template": "({a0}) - ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Mulf64Ty", + "template": "({a0}) * ({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Divf64Ty", + "template": "frac({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Powf64Ty", + "template": "({a0})^({a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Lower", + "template": "lower({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + }, + { + "variant_name": "T51Approx", + "template": "approx({a0}, {a1})", + "fields": [ + "a0", + "a1" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "T51Var", + "precedence": 100 + }, + { + "variant_name": "T51Num", + "precedence": 100 + }, + { + "variant_name": "T51Pi", + "precedence": 100 + }, + { + "variant_name": "T51Neg", + "precedence": 70 + }, + { + "variant_name": "T51Sin", + "precedence": 90 + }, + { + "variant_name": "T51Cos", + "precedence": 90 + }, + { + "variant_name": "T51Acos", + "precedence": 90 + }, + { + "variant_name": "T51Add", + "precedence": 50 + }, + { + "variant_name": "T51Sub", + "precedence": 50 + }, + { + "variant_name": "T51Mul", + "precedence": 60 + }, + { + "variant_name": "T51Div", + "precedence": 60 + }, + { + "variant_name": "T51Pow", + "precedence": 80 + }, + { + "variant_name": "T51Varbinary64", + "precedence": 100 + }, + { + "variant_name": "T51Numbinary64", + "precedence": 100 + }, + { + "variant_name": "T51Pif64Ty", + "precedence": 100 + }, + { + "variant_name": "T51Negf64Ty", + "precedence": 70 + }, + { + "variant_name": "T51Sinf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Cosf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Acosf64Ty", + "precedence": 90 + }, + { + "variant_name": "T51Addf64Ty", + "precedence": 50 + }, + { + "variant_name": "T51Subf64Ty", + "precedence": 50 + }, + { + "variant_name": "T51Mulf64Ty", + "precedence": 60 + }, + { + "variant_name": "T51Divf64Ty", + "precedence": 60 + }, + { + "variant_name": "T51Powf64Ty", + "precedence": 80 + }, + { + "variant_name": "T51Lower", + "precedence": 90 + }, + { + "variant_name": "T51Approx", + "precedence": 90 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "t51_lower_pow_binary64", + "premises": [ + { + "target_id": "lower_e", + "label": "lower_e", + "plain_source": "upright(\"lower_e\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $]" + }, + { + "target_id": "lower_a", + "label": "lower_a", + "plain_source": "upright(\"lower_a\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $]" + }, + { + "target_id": "lower_b", + "label": "lower_b", + "plain_source": "upright(\"lower_b\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_b\") $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "out", + "plain_source": "(upright(\"lower_a\"))^(upright(\"lower_b\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $])^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_b\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "lower_e", + "label": "lower_e", + "plain_source": "upright(\"lower_e\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "out", + "plain_source": "(upright(\"lower_a\"))^(upright(\"lower_b\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $])^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_b\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"lower_e\") \\ upright(\"lower_a\") \\ upright(\"lower_b\"), upright(\"lower_e\") arrow.r.double (upright(\"lower_a\"))^(upright(\"lower_b\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_b\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_e\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_a\") $])^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lower_b\") $]) $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "examples_action_sample_recorder_rs__72_5_SampleTx_add_rule_with_hook__sample_action_trace_rule__17f8316081369633", + "display_name": "sample_action_trace_rule", + "rule_name": "sample_action_trace_rule", + "callee": "SampleTx::add_rule_with_hook", + "file": "examples/action_sample_recorder.rs", + "offset": 1905, + "line": 72, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 1905, + "end": 2555 + }, + "pattern_range": { + "start": 1996, + "end": 2240 + }, + "action_range": { + "start": 2250, + "end": 2520 + } + }, + "nodes": [ + { + "id": "expr", + "kind": "query_leaf", + "dsl_type": "TraceExpr", + "label": "expr: TraceExpr", + "range": { + "start": 2013, + "end": 2048 + }, + "inputs": [] + }, + { + "id": "_root", + "kind": "query", + "dsl_type": "TraceRoot", + "label": "_root: TraceRoot", + "range": { + "start": 2061, + "end": 2097 + }, + "inputs": [ + "expr" + ] + } + ], + "edges": [ + { + "from": "_root", + "to": "expr", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "expr", + "expr" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@2383:2408", + "bound_var": "one", + "source_text": "ctx.insert_trace_const(1)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 2383, + "end": 2408 + } + }, + { + "id": "effect_1", + "effect_id": "effect@2434:2469", + "bound_var": "grown", + "source_text": "ctx.insert_trace_add(pat.expr, one)", + "semantic_text": null, + "referenced_pat_vars": [ + "expr" + ], + "referenced_action_vars": [ + "one" + ], + "range": { + "start": 2434, + "end": 2469 + } + }, + { + "id": "effect_2", + "effect_id": "effect@2483:2509", + "bound_var": null, + "source_text": "ctx.union(pat.expr, grown)", + "semantic_text": null, + "referenced_pat_vars": [ + "expr" + ], + "referenced_action_vars": [ + "grown" + ], + "range": { + "start": 2483, + "end": 2509 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "root.commit()", + "committed_root": "root", + "referenced_vars": [ + "root" + ], + "range": { + "start": 1734, + "end": 1747 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "sample_action_trace_rule", + "premises": [ + { + "target_id": "expr", + "label": "expr: TraceExpr", + "plain_source": "upright(\"expr\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $]" + }, + { + "target_id": "expr", + "label": "expr: TraceExpr", + "plain_source": "upright(\"expr\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "one", + "plain_source": "upright(\"TraceConst\")(1)", + "colored_source": "upright(\"TraceConst\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $])" + }, + { + "target_id": "effect:effect_1", + "label": "grown", + "plain_source": "upright(\"TraceAdd\")(upright(\"expr\"), upright(\"TraceConst\")(1))", + "colored_source": "upright(\"TraceAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $], upright(\"TraceConst\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $]))" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "expr", + "label": "expr: TraceExpr", + "plain_source": "upright(\"expr\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $]" + }, + "to": { + "target_id": "effect:effect_1", + "label": "grown", + "plain_source": "upright(\"TraceAdd\")(upright(\"expr\"), upright(\"TraceConst\")(1))", + "colored_source": "upright(\"TraceAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $], upright(\"TraceConst\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $]))" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"expr\") \\ upright(\"expr\"), upright(\"expr\") arrow.r.double upright(\"TraceAdd\")(upright(\"expr\"), upright(\"TraceConst\")(1))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $] arrow.r.double upright(\"TraceAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $], upright(\"TraceConst\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $]))) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "examples_add_rule_proof_smoke_rs__36_5_MyTxProof_add_rule__proof_smoke_rule__7aa3fc0143f3c924", + "display_name": "proof_smoke_rule", + "rule_name": "proof_smoke_rule", + "callee": "MyTxProof::add_rule", + "file": "examples/add_rule_proof_smoke.rs", + "offset": 1017, + "line": 36, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 1017, + "end": 1204 + }, + "pattern_range": { + "start": 1091, + "end": 1172 + }, + "action_range": { + "start": 1182, + "end": 1197 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Unit" + ], + "constraints": [], + "action_effects": [], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "proof_smoke_rule", + "premises": [ + { + "target_id": "Unit", + "label": "Unit", + "plain_source": "upright(\"Unit\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"Unit\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "examples_base_ty_def_rs__33_5_MyTx_add_rule__stringify_SubPat__be79a4c27e5eca48", + "display_name": "stringify!(SubPat)", + "rule_name": "stringify!(SubPat)", + "callee": "MyTx::add_rule", + "file": "examples/base_ty_def.rs", + "offset": 719, + "line": 33, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 719, + "end": 1500 + }, + "pattern_range": { + "start": 788, + "end": 1084 + }, + "action_range": { + "start": 1094, + "end": 1493 + } + }, + "nodes": [ + { + "id": "l", + "kind": "query_leaf", + "dsl_type": "Expr", + "label": "l: Expr", + "range": { + "start": 805, + "end": 832 + }, + "inputs": [] + }, + { + "id": "r", + "kind": "query_leaf", + "dsl_type": "Expr", + "label": "r: Expr", + "range": { + "start": 845, + "end": 872 + }, + "inputs": [] + }, + { + "id": "p", + "kind": "query", + "dsl_type": "Binary", + "label": "p: Binary", + "range": { + "start": 885, + "end": 915 + }, + "inputs": [ + "l", + "r" + ] + } + ], + "edges": [ + { + "from": "p", + "to": "l", + "kind": "operand", + "index": 0 + }, + { + "from": "p", + "to": "r", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "l", + "r", + "p" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@1303:1331", + "bound_var": "mul", + "source_text": "ctx.insert_mul(pat.l, pat.r)", + "semantic_text": null, + "referenced_pat_vars": [ + "l", + "r" + ], + "referenced_action_vars": [], + "range": { + "start": 1303, + "end": 1331 + } + }, + { + "id": "effect_1", + "effect_id": "effect@1353:1374", + "bound_var": null, + "source_text": "ctx.union(mul, pat.p)", + "semantic_text": null, + "referenced_pat_vars": [ + "p" + ], + "referenced_action_vars": [], + "range": { + "start": 1353, + "end": 1374 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "expr.commit()", + "committed_root": "expr", + "referenced_vars": [ + "expr" + ], + "range": { + "start": 655, + "end": 668 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "rule@719", + "premises": [ + { + "target_id": "p", + "label": "p: Binary", + "plain_source": "upright(\"Binary\")(l, r)", + "colored_source": "upright(\"Binary\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "mul", + "plain_source": "upright(\"Mul\")(l, r)", + "colored_source": "upright(\"Mul\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "mul", + "plain_source": "upright(\"Mul\")(l, r)", + "colored_source": "upright(\"Mul\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"Binary\")(l, r), upright(\"Mul\")(l, r)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"Binary\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $]), upright(\"Mul\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "examples_constant_prop_rs__53_5_MyTx_add_rule__stringify_AddPat__80bbfda4e5f7eb46", + "display_name": "stringify!(AddPat) @ examples/constant_prop.rs:53", + "rule_name": "stringify!(AddPat)", + "callee": "MyTx::add_rule", + "file": "examples/constant_prop.rs", + "offset": 1554, + "line": 53, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 1554, + "end": 2107 + }, + "pattern_range": { + "start": 1623, + "end": 1907 + }, + "action_range": { + "start": 1917, + "end": 2100 + } + }, + "nodes": [ + { + "id": "l", + "kind": "query", + "dsl_type": "Const", + "label": "l: Const", + "range": { + "start": 1640, + "end": 1663 + }, + "inputs": [] + }, + { + "id": "r", + "kind": "query", + "dsl_type": "Const", + "label": "r: Const", + "range": { + "start": 1676, + "end": 1699 + }, + "inputs": [] + }, + { + "id": "p", + "kind": "query", + "dsl_type": "Add", + "label": "p: Add", + "range": { + "start": 1712, + "end": 1739 + }, + "inputs": [ + "l", + "r" + ] + } + ], + "edges": [ + { + "from": "p", + "to": "l", + "kind": "operand", + "index": 0 + }, + { + "from": "p", + "to": "r", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "l", + "r", + "p" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@2028:2049", + "bound_var": "op_value", + "source_text": "ctx.insert_const(cal)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 2028, + "end": 2049 + } + }, + { + "id": "effect_1", + "effect_id": "effect@2063:2089", + "bound_var": null, + "source_text": "ctx.union(pat.p, op_value)", + "semantic_text": null, + "referenced_pat_vars": [ + "p" + ], + "referenced_action_vars": [ + "op_value" + ], + "range": { + "start": 2063, + "end": 2089 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "expr.commit()", + "committed_root": "expr", + "referenced_vars": [ + "expr" + ], + "range": { + "start": 1480, + "end": 1493 + } + } + ], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "Const", + "template": "{num}", + "fields": [ + "num" + ] + }, + { + "variant_name": "Mul", + "template": "{l} * {r}", + "fields": [ + "l", + "r" + ] + }, + { + "variant_name": "Sub", + "template": "{l} - {r}", + "fields": [ + "l", + "r" + ] + }, + { + "variant_name": "Add", + "template": "{l} + {r}", + "fields": [ + "l", + "r" + ] + }, + { + "variant_name": "Div", + "template": "frac({l}, {r})", + "fields": [ + "l", + "r" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Const", + "precedence": 100 + }, + { + "variant_name": "Mul", + "precedence": 60 + }, + { + "variant_name": "Sub", + "precedence": 50 + }, + { + "variant_name": "Add", + "precedence": 50 + }, + { + "variant_name": "Div", + "precedence": 60 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "rule@1554", + "premises": [ + { + "target_id": "l", + "label": "l: Const", + "plain_source": "l", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ l $]" + }, + { + "target_id": "r", + "label": "r: Const", + "plain_source": "r", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ r $]" + }, + { + "target_id": "p", + "label": "p: Add", + "plain_source": "l + r", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ l $] + #text(fill: rgb(\"#5F7A8A\"))[$ r $] $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "op_value", + "plain_source": "upright(\"cal\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ upright(\"cal\") $] $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "p", + "label": "p: Add", + "plain_source": "l + r", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ l $] + #text(fill: rgb(\"#5F7A8A\"))[$ r $] $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "op_value", + "plain_source": "upright(\"cal\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ upright(\"cal\") $] $]" + } + } + ], + "formula_source": { + "plain": "frac(l \\ r \\ l + r, l + r arrow.r.double upright(\"cal\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ l $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ r $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ l $] + #text(fill: rgb(\"#5F7A8A\"))[$ r $] $], #text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ l $] + #text(fill: rgb(\"#5F7A8A\"))[$ r $] $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ upright(\"cal\") $] $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "examples_constant_prop_proof_rs__100_5_MyTxProof_add_rule__ConstPropAddPat__1b50d79b988604f5", + "display_name": "ConstPropAddPat", + "rule_name": "ConstPropAddPat", + "callee": "MyTxProof::add_rule", + "file": "examples/constant_prop_proof.rs", + "offset": 3000, + "line": 100, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 3000, + "end": 3566 + }, + "pattern_range": { + "start": 3073, + "end": 3366 + }, + "action_range": { + "start": 3376, + "end": 3559 + } + }, + "nodes": [ + { + "id": "l", + "kind": "query", + "dsl_type": "Const", + "label": "l: Const", + "range": { + "start": 3090, + "end": 3113 + }, + "inputs": [] + }, + { + "id": "r", + "kind": "query", + "dsl_type": "Const", + "label": "r: Const", + "range": { + "start": 3126, + "end": 3149 + }, + "inputs": [] + }, + { + "id": "p", + "kind": "query", + "dsl_type": "Add", + "label": "p: Add", + "range": { + "start": 3162, + "end": 3189 + }, + "inputs": [ + "l", + "r" + ] + } + ], + "edges": [ + { + "from": "p", + "to": "l", + "kind": "operand", + "index": 0 + }, + { + "from": "p", + "to": "r", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "l", + "r", + "p" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@3487:3508", + "bound_var": "op_value", + "source_text": "ctx.insert_const(cal)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 3487, + "end": 3508 + } + }, + { + "id": "effect_1", + "effect_id": "effect@3522:3548", + "bound_var": null, + "source_text": "ctx.union(pat.p, op_value)", + "semantic_text": null, + "referenced_pat_vars": [ + "p" + ], + "referenced_action_vars": [ + "op_value" + ], + "range": { + "start": 3522, + "end": 3548 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "expr.commit()", + "committed_root": "expr", + "referenced_vars": [ + "expr" + ], + "range": { + "start": 2522, + "end": 2535 + } + }, + { + "id": "seed_1", + "source_text": "expected.commit()", + "committed_root": "expected", + "referenced_vars": [ + "expected" + ], + "range": { + "start": 2701, + "end": 2718 + } + }, + { + "id": "seed_2", + "source_text": "expected_mul.commit()", + "committed_root": "expected_mul", + "referenced_vars": [ + "expected_mul" + ], + "range": { + "start": 2847, + "end": 2868 + } + } + ], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Const", + "template": "{num}", + "fields": [ + "num" + ] + }, + { + "variant_name": "Mul", + "template": "{l} * {r}", + "fields": [ + "l", + "r" + ] + }, + { + "variant_name": "Sub", + "template": "{l} - {r}", + "fields": [ + "l", + "r" + ] + }, + { + "variant_name": "Add", + "template": "{l} + {r}", + "fields": [ + "l", + "r" + ] + }, + { + "variant_name": "Div", + "template": "frac({l}, {r})", + "fields": [ + "l", + "r" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Var", + "precedence": 100 + }, + { + "variant_name": "Const", + "precedence": 100 + }, + { + "variant_name": "Mul", + "precedence": 60 + }, + { + "variant_name": "Sub", + "precedence": 50 + }, + { + "variant_name": "Add", + "precedence": 50 + }, + { + "variant_name": "Div", + "precedence": 60 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "ConstPropAddPat", + "premises": [ + { + "target_id": "l", + "label": "l: Const", + "plain_source": "l", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ l $]" + }, + { + "target_id": "r", + "label": "r: Const", + "plain_source": "r", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ r $]" + }, + { + "target_id": "p", + "label": "p: Add", + "plain_source": "l + r", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ l $] + #text(fill: rgb(\"#5F7A8A\"))[$ r $] $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "op_value", + "plain_source": "upright(\"cal\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ upright(\"cal\") $] $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "p", + "label": "p: Add", + "plain_source": "l + r", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ l $] + #text(fill: rgb(\"#5F7A8A\"))[$ r $] $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "op_value", + "plain_source": "upright(\"cal\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ upright(\"cal\") $] $]" + } + } + ], + "formula_source": { + "plain": "frac(l \\ r \\ l + r, l + r arrow.r.double upright(\"cal\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ l $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ r $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ l $] + #text(fill: rgb(\"#5F7A8A\"))[$ r $] $], #text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ l $] + #text(fill: rgb(\"#5F7A8A\"))[$ r $] $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ upright(\"cal\") $] $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "examples_constant_prop_proof_rs__121_5_MyTxProof_add_rule__ConstPropMulPat__ccd00747b0b56bcf", + "display_name": "ConstPropMulPat", + "rule_name": "ConstPropMulPat", + "callee": "MyTxProof::add_rule", + "file": "examples/constant_prop_proof.rs", + "offset": 3608, + "line": 121, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 3608, + "end": 4174 + }, + "pattern_range": { + "start": 3681, + "end": 3974 + }, + "action_range": { + "start": 3984, + "end": 4167 + } + }, + "nodes": [ + { + "id": "l", + "kind": "query", + "dsl_type": "Const", + "label": "l: Const", + "range": { + "start": 3698, + "end": 3721 + }, + "inputs": [] + }, + { + "id": "r", + "kind": "query", + "dsl_type": "Const", + "label": "r: Const", + "range": { + "start": 3734, + "end": 3757 + }, + "inputs": [] + }, + { + "id": "p", + "kind": "query", + "dsl_type": "Mul", + "label": "p: Mul", + "range": { + "start": 3770, + "end": 3797 + }, + "inputs": [ + "l", + "r" + ] + } + ], + "edges": [ + { + "from": "p", + "to": "l", + "kind": "operand", + "index": 0 + }, + { + "from": "p", + "to": "r", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "l", + "r", + "p" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@4095:4116", + "bound_var": "op_value", + "source_text": "ctx.insert_const(cal)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 4095, + "end": 4116 + } + }, + { + "id": "effect_1", + "effect_id": "effect@4130:4156", + "bound_var": null, + "source_text": "ctx.union(pat.p, op_value)", + "semantic_text": null, + "referenced_pat_vars": [ + "p" + ], + "referenced_action_vars": [ + "op_value" + ], + "range": { + "start": 4130, + "end": 4156 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "expr.commit()", + "committed_root": "expr", + "referenced_vars": [ + "expr" + ], + "range": { + "start": 2522, + "end": 2535 + } + }, + { + "id": "seed_1", + "source_text": "expected.commit()", + "committed_root": "expected", + "referenced_vars": [ + "expected" + ], + "range": { + "start": 2701, + "end": 2718 + } + }, + { + "id": "seed_2", + "source_text": "expected_mul.commit()", + "committed_root": "expected_mul", + "referenced_vars": [ + "expected_mul" + ], + "range": { + "start": 2847, + "end": 2868 + } + } + ], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Const", + "template": "{num}", + "fields": [ + "num" + ] + }, + { + "variant_name": "Mul", + "template": "{l} * {r}", + "fields": [ + "l", + "r" + ] + }, + { + "variant_name": "Sub", + "template": "{l} - {r}", + "fields": [ + "l", + "r" + ] + }, + { + "variant_name": "Add", + "template": "{l} + {r}", + "fields": [ + "l", + "r" + ] + }, + { + "variant_name": "Div", + "template": "frac({l}, {r})", + "fields": [ + "l", + "r" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Var", + "precedence": 100 + }, + { + "variant_name": "Const", + "precedence": 100 + }, + { + "variant_name": "Mul", + "precedence": 60 + }, + { + "variant_name": "Sub", + "precedence": 50 + }, + { + "variant_name": "Add", + "precedence": 50 + }, + { + "variant_name": "Div", + "precedence": 60 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "ConstPropMulPat", + "premises": [ + { + "target_id": "l", + "label": "l: Const", + "plain_source": "l", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ l $]" + }, + { + "target_id": "r", + "label": "r: Const", + "plain_source": "r", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ r $]" + }, + { + "target_id": "p", + "label": "p: Mul", + "plain_source": "l * r", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ l $] * #text(fill: rgb(\"#5F7A8A\"))[$ r $] $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "op_value", + "plain_source": "upright(\"cal\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ upright(\"cal\") $] $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "p", + "label": "p: Mul", + "plain_source": "l * r", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ l $] * #text(fill: rgb(\"#5F7A8A\"))[$ r $] $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "op_value", + "plain_source": "upright(\"cal\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ upright(\"cal\") $] $]" + } + } + ], + "formula_source": { + "plain": "frac(l \\ r \\ l * r, l * r arrow.r.double upright(\"cal\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ l $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ r $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ l $] * #text(fill: rgb(\"#5F7A8A\"))[$ r $] $], #text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ l $] * #text(fill: rgb(\"#5F7A8A\"))[$ r $] $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ upright(\"cal\") $] $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "examples_constant_prop_proof_rs__192_5_MyTxProof_add_rule__ConstPropAddCommPat__067c9f76185634be", + "display_name": "ConstPropAddCommPat", + "rule_name": "ConstPropAddCommPat", + "callee": "MyTxProof::add_rule", + "file": "examples/constant_prop_proof.rs", + "offset": 6178, + "line": 192, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 6178, + "end": 6701 + }, + "pattern_range": { + "start": 6264, + "end": 6567 + }, + "action_range": { + "start": 6577, + "end": 6694 + } + }, + "nodes": [ + { + "id": "a", + "kind": "query_leaf", + "dsl_type": "Expr", + "label": "a: Expr", + "range": { + "start": 6281, + "end": 6308 + }, + "inputs": [] + }, + { + "id": "b", + "kind": "query_leaf", + "dsl_type": "Expr", + "label": "b: Expr", + "range": { + "start": 6321, + "end": 6348 + }, + "inputs": [] + }, + { + "id": "p", + "kind": "query", + "dsl_type": "Add", + "label": "p: Add", + "range": { + "start": 6361, + "end": 6388 + }, + "inputs": [ + "a", + "b" + ] + } + ], + "edges": [ + { + "from": "p", + "to": "a", + "kind": "operand", + "index": 0 + }, + { + "from": "p", + "to": "b", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "a", + "b", + "p" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@6616:6644", + "bound_var": "swapped", + "source_text": "ctx.insert_add(pat.b, pat.a)", + "semantic_text": null, + "referenced_pat_vars": [ + "a", + "b" + ], + "referenced_action_vars": [], + "range": { + "start": 6616, + "end": 6644 + } + }, + { + "id": "effect_1", + "effect_id": "effect@6658:6683", + "bound_var": null, + "source_text": "ctx.union(pat.p, swapped)", + "semantic_text": null, + "referenced_pat_vars": [ + "p" + ], + "referenced_action_vars": [ + "swapped" + ], + "range": { + "start": 6658, + "end": 6683 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "expr.commit()", + "committed_root": "expr", + "referenced_vars": [ + "expr" + ], + "range": { + "start": 2522, + "end": 2535 + } + }, + { + "id": "seed_1", + "source_text": "expected.commit()", + "committed_root": "expected", + "referenced_vars": [ + "expected" + ], + "range": { + "start": 2701, + "end": 2718 + } + }, + { + "id": "seed_2", + "source_text": "expected_mul.commit()", + "committed_root": "expected_mul", + "referenced_vars": [ + "expected_mul" + ], + "range": { + "start": 2847, + "end": 2868 + } + } + ], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Const", + "template": "{num}", + "fields": [ + "num" + ] + }, + { + "variant_name": "Mul", + "template": "{l} * {r}", + "fields": [ + "l", + "r" + ] + }, + { + "variant_name": "Sub", + "template": "{l} - {r}", + "fields": [ + "l", + "r" + ] + }, + { + "variant_name": "Add", + "template": "{l} + {r}", + "fields": [ + "l", + "r" + ] + }, + { + "variant_name": "Div", + "template": "frac({l}, {r})", + "fields": [ + "l", + "r" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Var", + "precedence": 100 + }, + { + "variant_name": "Const", + "precedence": 100 + }, + { + "variant_name": "Mul", + "precedence": 60 + }, + { + "variant_name": "Sub", + "precedence": 50 + }, + { + "variant_name": "Add", + "precedence": 50 + }, + { + "variant_name": "Div", + "precedence": 60 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "ConstPropAddCommPat", + "premises": [ + { + "target_id": "p", + "label": "p: Add", + "plain_source": "a + b", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ a $] + #text(fill: rgb(\"#5F7A8A\"))[$ b $] $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "swapped", + "plain_source": "b + a", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ b $] + #text(fill: rgb(\"#5F7A8A\"))[$ a $] $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "p", + "label": "p: Add", + "plain_source": "a + b", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ a $] + #text(fill: rgb(\"#5F7A8A\"))[$ b $] $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "swapped", + "plain_source": "b + a", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ b $] + #text(fill: rgb(\"#5F7A8A\"))[$ a $] $]" + } + } + ], + "formula_source": { + "plain": "frac(a + b, a + b arrow.r.double b + a) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ a $] + #text(fill: rgb(\"#5F7A8A\"))[$ b $] $], #text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ a $] + #text(fill: rgb(\"#5F7A8A\"))[$ b $] $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ b $] + #text(fill: rgb(\"#5F7A8A\"))[$ a $] $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "examples_constrain_basic_rs__18_5_MyTx_add_rule__stringify_AddPat__e46f04f61f9f7c9b", + "display_name": "stringify!(AddPat) @ examples/constrain_basic.rs:18", + "rule_name": "stringify!(AddPat)", + "callee": "MyTx::add_rule", + "file": "examples/constrain_basic.rs", + "offset": 452, + "line": 18, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 452, + "end": 1013 + }, + "pattern_range": { + "start": 521, + "end": 813 + }, + "action_range": { + "start": 823, + "end": 1006 + } + }, + "nodes": [ + { + "id": "r", + "kind": "query", + "dsl_type": "Const", + "label": "r: Const", + "range": { + "start": 582, + "end": 605 + }, + "inputs": [] + }, + { + "id": "p", + "kind": "query", + "dsl_type": "Add", + "label": "p: Add", + "range": { + "start": 618, + "end": 645 + }, + "inputs": [ + "l", + "r" + ] + } + ], + "edges": [ + { + "from": "p", + "to": "l", + "kind": "operand", + "index": 0 + }, + { + "from": "p", + "to": "r", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "l", + "r", + "p" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@934:955", + "bound_var": "op_value", + "source_text": "ctx.insert_const(cal)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 934, + "end": 955 + } + }, + { + "id": "effect_1", + "effect_id": "effect@969:995", + "bound_var": null, + "source_text": "ctx.union(pat.p, op_value)", + "semantic_text": null, + "referenced_pat_vars": [ + "p" + ], + "referenced_action_vars": [ + "op_value" + ], + "range": { + "start": 969, + "end": 995 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "expr.commit()", + "committed_root": "expr", + "referenced_vars": [ + "expr" + ], + "range": { + "start": 433, + "end": 446 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "rule@452", + "premises": [ + { + "target_id": "r", + "label": "r: Const", + "plain_source": "r", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ r $]" + }, + { + "target_id": "p", + "label": "p: Add", + "plain_source": "upright(\"Add\")(l, r)", + "colored_source": "upright(\"Add\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "op_value", + "plain_source": "upright(\"Const\")(upright(\"cal\"))", + "colored_source": "upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"cal\") $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "p", + "label": "p: Add", + "plain_source": "upright(\"Add\")(l, r)", + "colored_source": "upright(\"Add\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "op_value", + "plain_source": "upright(\"Const\")(upright(\"cal\"))", + "colored_source": "upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"cal\") $])" + } + } + ], + "formula_source": { + "plain": "frac(r \\ upright(\"Add\")(l, r), upright(\"Add\")(l, r) arrow.r.double upright(\"Const\")(upright(\"cal\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ r $] \\ upright(\"Add\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $]), upright(\"Add\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $]) arrow.r.double upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"cal\") $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "examples_constrain_complex_rs__19_5_MyTx_add_rule__stringify_AddPat__6f9905d03582f742", + "display_name": "stringify!(AddPat) @ examples/constrain_complex.rs:19", + "rule_name": "stringify!(AddPat)", + "callee": "MyTx::add_rule", + "file": "examples/constrain_complex.rs", + "offset": 476, + "line": 19, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 476, + "end": 1170 + }, + "pattern_range": { + "start": 545, + "end": 970 + }, + "action_range": { + "start": 980, + "end": 1163 + } + }, + "nodes": [ + { + "id": "l", + "kind": "query", + "dsl_type": "Const", + "label": "l: Const", + "range": { + "start": 562, + "end": 585 + }, + "inputs": [] + }, + { + "id": "r", + "kind": "query", + "dsl_type": "Const", + "label": "r: Const", + "range": { + "start": 598, + "end": 621 + }, + "inputs": [] + }, + { + "id": "p", + "kind": "query", + "dsl_type": "Add", + "label": "p: Add", + "range": { + "start": 634, + "end": 661 + }, + "inputs": [ + "l", + "r" + ] + } + ], + "edges": [ + { + "from": "p", + "to": "l", + "kind": "operand", + "index": 0 + }, + { + "from": "p", + "to": "r", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "l", + "r", + "p" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "l_h_eq_r_h", + "resolved_text": "l.handle().eq(&r.handle())", + "semantic_text": "l == r", + "referenced_vars": [ + "l", + "r" + ], + "range": { + "start": 949, + "end": 959 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@1091:1112", + "bound_var": "op_value", + "source_text": "ctx.insert_const(cal)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 1091, + "end": 1112 + } + }, + { + "id": "effect_1", + "effect_id": "effect@1126:1152", + "bound_var": null, + "source_text": "ctx.union(pat.p, op_value)", + "semantic_text": null, + "referenced_pat_vars": [ + "p" + ], + "referenced_action_vars": [ + "op_value" + ], + "range": { + "start": 1126, + "end": 1152 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "expr.commit()", + "committed_root": "expr", + "referenced_vars": [ + "expr" + ], + "range": { + "start": 402, + "end": 415 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "rule@476", + "premises": [ + { + "target_id": "l", + "label": "l: Const", + "plain_source": "l", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ l $]" + }, + { + "target_id": "r", + "label": "r: Const", + "plain_source": "r", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ r $]" + }, + { + "target_id": "p", + "label": "p: Add", + "plain_source": "upright(\"Add\")(l, r)", + "colored_source": "upright(\"Add\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])" + } + ], + "side_conditions": [ + "l == r" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "op_value", + "plain_source": "upright(\"Const\")(upright(\"cal\"))", + "colored_source": "upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"cal\") $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "p", + "label": "p: Add", + "plain_source": "upright(\"Add\")(l, r)", + "colored_source": "upright(\"Add\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "op_value", + "plain_source": "upright(\"Const\")(upright(\"cal\"))", + "colored_source": "upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"cal\") $])" + } + } + ], + "formula_source": { + "plain": "frac(l \\ r \\ upright(\"Add\")(l, r), upright(\"Add\")(l, r) arrow.r.double upright(\"Const\")(upright(\"cal\"))) quad upright(\"if\") quad l == r", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ l $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ r $] \\ upright(\"Add\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $]), upright(\"Add\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $]) arrow.r.double upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"cal\") $])) quad upright(\"if\") quad l == r" + } + } + } + }, + { + "id": "examples_constrain_complex_rs__49_5_MyTx_add_rule__stringify_MulPat__59784ec035b4adda", + "display_name": "stringify!(MulPat)", + "rule_name": "stringify!(MulPat)", + "callee": "MyTx::add_rule", + "file": "examples/constrain_complex.rs", + "offset": 1280, + "line": 49, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 1280, + "end": 1780 + }, + "pattern_range": { + "start": 1349, + "end": 1580 + }, + "action_range": { + "start": 1590, + "end": 1773 + } + }, + "nodes": [ + { + "id": "l", + "kind": "query", + "dsl_type": "Const", + "label": "l: Const", + "range": { + "start": 1366, + "end": 1389 + }, + "inputs": [] + }, + { + "id": "r", + "kind": "query", + "dsl_type": "Const", + "label": "r: Const", + "range": { + "start": 1402, + "end": 1425 + }, + "inputs": [] + }, + { + "id": "p", + "kind": "query", + "dsl_type": "Mul", + "label": "p: Mul", + "range": { + "start": 1438, + "end": 1465 + }, + "inputs": [ + "l", + "r" + ] + } + ], + "edges": [ + { + "from": "p", + "to": "l", + "kind": "operand", + "index": 0 + }, + { + "from": "p", + "to": "r", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "l", + "r", + "p" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "l_r_eq", + "resolved_text": "{ l.handle().eq(&r.handle()) }", + "semantic_text": null, + "referenced_vars": [ + "l", + "r" + ], + "range": { + "start": 1563, + "end": 1569 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@1701:1722", + "bound_var": "op_value", + "source_text": "ctx.insert_const(cal)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 1701, + "end": 1722 + } + }, + { + "id": "effect_1", + "effect_id": "effect@1736:1762", + "bound_var": null, + "source_text": "ctx.union(pat.p, op_value)", + "semantic_text": null, + "referenced_pat_vars": [ + "p" + ], + "referenced_action_vars": [ + "op_value" + ], + "range": { + "start": 1736, + "end": 1762 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "expr.commit()", + "committed_root": "expr", + "referenced_vars": [ + "expr" + ], + "range": { + "start": 402, + "end": 415 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "rule@1280", + "premises": [ + { + "target_id": "l", + "label": "l: Const", + "plain_source": "l", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ l $]" + }, + { + "target_id": "r", + "label": "r: Const", + "plain_source": "r", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ r $]" + }, + { + "target_id": "p", + "label": "p: Mul", + "plain_source": "upright(\"Mul\")(l, r)", + "colored_source": "upright(\"Mul\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])" + } + ], + "side_conditions": [ + "l_r_eq [raw]" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "op_value", + "plain_source": "upright(\"Const\")(upright(\"cal\"))", + "colored_source": "upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"cal\") $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "p", + "label": "p: Mul", + "plain_source": "upright(\"Mul\")(l, r)", + "colored_source": "upright(\"Mul\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "op_value", + "plain_source": "upright(\"Const\")(upright(\"cal\"))", + "colored_source": "upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"cal\") $])" + } + } + ], + "formula_source": { + "plain": "frac(l \\ r \\ upright(\"Mul\")(l, r), upright(\"Mul\")(l, r) arrow.r.double upright(\"Const\")(upright(\"cal\"))) quad upright(\"if\") quad l_r_eq [raw]", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ l $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ r $] \\ upright(\"Mul\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $]), upright(\"Mul\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $]) arrow.r.double upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"cal\") $])) quad upright(\"if\") quad l_r_eq [raw]" + } + } + } + }, + { + "id": "examples_constrain_lt100_test_rs__27_5_MyTx_add_rule__stringify_AddPat__0635152630db8235", + "display_name": "stringify!(AddPat) @ examples/constrain_lt100_test.rs:27", + "rule_name": "stringify!(AddPat)", + "callee": "MyTx::add_rule", + "file": "examples/constrain_lt100_test.rs", + "offset": 741, + "line": 27, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 741, + "end": 1860 + }, + "pattern_range": { + "start": 810, + "end": 1445 + }, + "action_range": { + "start": 1455, + "end": 1853 + } + }, + "nodes": [ + { + "id": "l", + "kind": "query", + "dsl_type": "Const", + "label": "l: Const", + "range": { + "start": 827, + "end": 850 + }, + "inputs": [] + }, + { + "id": "r", + "kind": "query", + "dsl_type": "Const", + "label": "r: Const", + "range": { + "start": 863, + "end": 886 + }, + "inputs": [] + }, + { + "id": "p", + "kind": "query", + "dsl_type": "Add", + "label": "p: Add", + "range": { + "start": 899, + "end": 926 + }, + "inputs": [ + "l", + "r" + ] + } + ], + "edges": [ + { + "from": "p", + "to": "l", + "kind": "operand", + "index": 0 + }, + { + "from": "p", + "to": "r", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "l", + "r", + "p" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "r_lt_100", + "resolved_text": "r.handle_num().lt(&100)", + "semantic_text": "r.num < 100", + "referenced_vars": [ + "r" + ], + "range": { + "start": 1396, + "end": 1404 + } + }, + { + "id": "constraint_1", + "source_text": "l_lt_100", + "resolved_text": "l\n .handle_num()\n .lt(&((&50i64).as_handle() * (&2i64).as_handle()))", + "semantic_text": "l\n .handle_num() < 50i64 * 2i64", + "referenced_vars": [ + "l" + ], + "range": { + "start": 1426, + "end": 1434 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@1781:1802", + "bound_var": "op_value", + "source_text": "ctx.insert_const(sum)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 1781, + "end": 1802 + } + }, + { + "id": "effect_1", + "effect_id": "effect@1816:1842", + "bound_var": null, + "source_text": "ctx.union(pat.p, op_value)", + "semantic_text": null, + "referenced_pat_vars": [ + "p" + ], + "referenced_action_vars": [ + "op_value" + ], + "range": { + "start": 1816, + "end": 1842 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "expr1.commit()", + "committed_root": "expr1", + "referenced_vars": [ + "expr1" + ], + "range": { + "start": 375, + "end": 389 + } + }, + { + "id": "seed_1", + "source_text": "expr2.commit()", + "committed_root": "expr2", + "referenced_vars": [ + "expr2" + ], + "range": { + "start": 587, + "end": 601 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "rule@741", + "premises": [ + { + "target_id": "l", + "label": "l: Const", + "plain_source": "l", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ l $]" + }, + { + "target_id": "r", + "label": "r: Const", + "plain_source": "r", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ r $]" + }, + { + "target_id": "p", + "label": "p: Add", + "plain_source": "upright(\"Add\")(l, r)", + "colored_source": "upright(\"Add\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])" + } + ], + "side_conditions": [ + "upright(\"r.num\") < 100", + "l\n .upright(\"handle_num\")() < 50i_64 * 2i_64" + ], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "op_value", + "plain_source": "upright(\"Const\")(upright(\"sum\"))", + "colored_source": "upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"sum\") $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "p", + "label": "p: Add", + "plain_source": "upright(\"Add\")(l, r)", + "colored_source": "upright(\"Add\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "op_value", + "plain_source": "upright(\"Const\")(upright(\"sum\"))", + "colored_source": "upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"sum\") $])" + } + } + ], + "formula_source": { + "plain": "frac(l \\ r \\ upright(\"Add\")(l, r), upright(\"Add\")(l, r) arrow.r.double upright(\"Const\")(upright(\"sum\"))) quad upright(\"if\") quad upright(\"r.num\") < 100 \\ l\n .upright(\"handle_num\")() < 50i_64 * 2i_64", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ l $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ r $] \\ upright(\"Add\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $]), upright(\"Add\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $]) arrow.r.double upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"sum\") $])) quad upright(\"if\") quad upright(\"r.num\") < 100 \\ l\n .upright(\"handle_num\")() < 50i_64 * 2i_64" + } + } + } + }, + { + "id": "examples_container_rs__34_5_MyTx_add_rule__sum_vec__4e3df859734a02bd", + "display_name": "sum_vec", + "rule_name": "sum_vec", + "callee": "MyTx::add_rule", + "file": "examples/container.rs", + "offset": 739, + "line": 34, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 739, + "end": 1506 + }, + "pattern_range": { + "start": 799, + "end": 911 + }, + "action_range": { + "start": 921, + "end": 1499 + } + }, + "nodes": [ + { + "id": "vec_expr", + "kind": "query_leaf", + "dsl_type": "Array", + "label": "vec_expr: Array", + "range": { + "start": 816, + "end": 851 + }, + "inputs": [] + } + ], + "edges": [], + "roots": [], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@981:1146", + "bound_var": null, + "source_text": "ctx.insert_vec_sum(ctx.insert_array({\n let mut v = VecContainer::new();\n v.push(ctx.insert_const(3));\n v\n }))", + "semantic_text": null, + "referenced_pat_vars": [ + "vec_expr" + ], + "referenced_action_vars": [ + "tmp_0", + "v" + ], + "range": { + "start": 981, + "end": 1146 + } + }, + { + "id": "effect_1", + "effect_id": "effect@1000:1145", + "bound_var": "tmp_0", + "source_text": "ctx.insert_array({\n let mut v = VecContainer::new();\n v.push(ctx.insert_const(3));\n v\n })", + "semantic_text": null, + "referenced_pat_vars": [ + "vec_expr" + ], + "referenced_action_vars": [ + "v" + ], + "range": { + "start": 1000, + "end": 1145 + } + }, + { + "id": "effect_2", + "effect_id": "effect@1091:1110", + "bound_var": "tmp_1", + "source_text": "ctx.insert_const(3)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 1091, + "end": 1110 + } + }, + { + "id": "effect_3", + "effect_id": "effect@1160:1338", + "bound_var": null, + "source_text": "ctx.insert_var_set(ctx.insert_set_struct({\n let mut set = SetContainer::new();\n set.insert(ctx.insert_const(4));\n set\n }))", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "tmp_2" + ], + "range": { + "start": 1160, + "end": 1338 + } + }, + { + "id": "effect_4", + "effect_id": "effect@1179:1337", + "bound_var": "tmp_2", + "source_text": "ctx.insert_set_struct({\n let mut set = SetContainer::new();\n set.insert(ctx.insert_const(4));\n set\n })", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 1179, + "end": 1337 + } + }, + { + "id": "effect_5", + "effect_id": "effect@1281:1300", + "bound_var": "tmp_3", + "source_text": "ctx.insert_const(4)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 1281, + "end": 1300 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "expr.commit()", + "committed_root": "expr", + "referenced_vars": [ + "expr" + ], + "range": { + "start": 665, + "end": 678 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [ + { + "severity": "warning", + "message": "Pat::new(...) found, but no root variables could be extracted", + "range": { + "start": 864, + "end": 901 + } + } + ], + "math_view": { + "rule_name": "sum_vec", + "premises": [], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_2", + "label": "tmp_1", + "plain_source": "upright(\"Const\")(3)", + "colored_source": "upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ 3 $])" + }, + { + "target_id": "effect:effect_5", + "label": "tmp_3", + "plain_source": "upright(\"Const\")(4)", + "colored_source": "upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ 4 $])" + } + ], + "conclusions": [ + { + "kind": "derive", + "id": "effect_2", + "entry": { + "target_id": "effect:effect_2", + "label": "tmp_1", + "plain_source": "upright(\"Const\")(3)", + "colored_source": "upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ 3 $])" + } + }, + { + "kind": "derive", + "id": "effect_5", + "entry": { + "target_id": "effect:effect_5", + "label": "tmp_3", + "plain_source": "upright(\"Const\")(4)", + "colored_source": "upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ 4 $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"no matched premise\"), upright(\"Const\")(3) \\ upright(\"Const\")(4)) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"no matched premise\"), upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ 3 $]) \\ upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ 4 $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "examples_debug_const_prop_proof_tables_rs__179_5_DebugTxProof_add_rule__DebugConstPropAddPat__461400b731955d9e", + "display_name": "DebugConstPropAddPat", + "rule_name": "DebugConstPropAddPat", + "callee": "DebugTxProof::add_rule", + "file": "examples/debug_const_prop_proof_tables.rs", + "offset": 4675, + "line": 179, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 4675, + "end": 5254 + }, + "pattern_range": { + "start": 4756, + "end": 5054 + }, + "action_range": { + "start": 5064, + "end": 5247 + } + }, + "nodes": [ + { + "id": "l", + "kind": "query", + "dsl_type": "Const", + "label": "l: Const", + "range": { + "start": 4773, + "end": 4796 + }, + "inputs": [] + }, + { + "id": "r", + "kind": "query", + "dsl_type": "Const", + "label": "r: Const", + "range": { + "start": 4809, + "end": 4832 + }, + "inputs": [] + }, + { + "id": "p", + "kind": "query", + "dsl_type": "Add", + "label": "p: Add", + "range": { + "start": 4845, + "end": 4872 + }, + "inputs": [ + "l", + "r" + ] + } + ], + "edges": [ + { + "from": "p", + "to": "l", + "kind": "operand", + "index": 0 + }, + { + "from": "p", + "to": "r", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "l", + "r", + "p" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@5175:5196", + "bound_var": "op_value", + "source_text": "ctx.insert_const(cal)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 5175, + "end": 5196 + } + }, + { + "id": "effect_1", + "effect_id": "effect@5210:5236", + "bound_var": null, + "source_text": "ctx.union(pat.p, op_value)", + "semantic_text": null, + "referenced_pat_vars": [ + "p" + ], + "referenced_action_vars": [ + "op_value" + ], + "range": { + "start": 5210, + "end": 5236 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "expr.commit()", + "committed_root": "expr", + "referenced_vars": [ + "expr" + ], + "range": { + "start": 4171, + "end": 4184 + } + }, + { + "id": "seed_1", + "source_text": "expected.commit()", + "committed_root": "expected", + "referenced_vars": [ + "expected" + ], + "range": { + "start": 4255, + "end": 4272 + } + }, + { + "id": "seed_2", + "source_text": "expected_mul.commit()", + "committed_root": "expected_mul", + "referenced_vars": [ + "expected_mul" + ], + "range": { + "start": 4346, + "end": 4367 + } + } + ], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "Const", + "template": "{num}", + "fields": [ + "num" + ] + }, + { + "variant_name": "Mul", + "template": "{l} * {r}", + "fields": [ + "l", + "r" + ] + }, + { + "variant_name": "Sub", + "template": "{l} - {r}", + "fields": [ + "l", + "r" + ] + }, + { + "variant_name": "Add", + "template": "{l} + {r}", + "fields": [ + "l", + "r" + ] + }, + { + "variant_name": "Div", + "template": "frac({l}, {r})", + "fields": [ + "l", + "r" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Const", + "precedence": 100 + }, + { + "variant_name": "Mul", + "precedence": 60 + }, + { + "variant_name": "Sub", + "precedence": 50 + }, + { + "variant_name": "Add", + "precedence": 50 + }, + { + "variant_name": "Div", + "precedence": 60 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "DebugConstPropAddPat", + "premises": [ + { + "target_id": "l", + "label": "l: Const", + "plain_source": "l", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ l $]" + }, + { + "target_id": "r", + "label": "r: Const", + "plain_source": "r", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ r $]" + }, + { + "target_id": "p", + "label": "p: Add", + "plain_source": "l + r", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ l $] + #text(fill: rgb(\"#5F7A8A\"))[$ r $] $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "op_value", + "plain_source": "upright(\"cal\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ upright(\"cal\") $] $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "p", + "label": "p: Add", + "plain_source": "l + r", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ l $] + #text(fill: rgb(\"#5F7A8A\"))[$ r $] $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "op_value", + "plain_source": "upright(\"cal\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ upright(\"cal\") $] $]" + } + } + ], + "formula_source": { + "plain": "frac(l \\ r \\ l + r, l + r arrow.r.double upright(\"cal\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ l $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ r $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ l $] + #text(fill: rgb(\"#5F7A8A\"))[$ r $] $], #text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ l $] + #text(fill: rgb(\"#5F7A8A\"))[$ r $] $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ upright(\"cal\") $] $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "examples_debug_const_prop_proof_tables_rs__200_5_DebugTxProof_add_rule__DebugConstPropMulPat__3449d52121fe15a4", + "display_name": "DebugConstPropMulPat", + "rule_name": "DebugConstPropMulPat", + "callee": "DebugTxProof::add_rule", + "file": "examples/debug_const_prop_proof_tables.rs", + "offset": 5296, + "line": 200, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 5296, + "end": 5875 + }, + "pattern_range": { + "start": 5377, + "end": 5675 + }, + "action_range": { + "start": 5685, + "end": 5868 + } + }, + "nodes": [ + { + "id": "l", + "kind": "query", + "dsl_type": "Const", + "label": "l: Const", + "range": { + "start": 5394, + "end": 5417 + }, + "inputs": [] + }, + { + "id": "r", + "kind": "query", + "dsl_type": "Const", + "label": "r: Const", + "range": { + "start": 5430, + "end": 5453 + }, + "inputs": [] + }, + { + "id": "p", + "kind": "query", + "dsl_type": "Mul", + "label": "p: Mul", + "range": { + "start": 5466, + "end": 5493 + }, + "inputs": [ + "l", + "r" + ] + } + ], + "edges": [ + { + "from": "p", + "to": "l", + "kind": "operand", + "index": 0 + }, + { + "from": "p", + "to": "r", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "l", + "r", + "p" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@5796:5817", + "bound_var": "op_value", + "source_text": "ctx.insert_const(cal)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 5796, + "end": 5817 + } + }, + { + "id": "effect_1", + "effect_id": "effect@5831:5857", + "bound_var": null, + "source_text": "ctx.union(pat.p, op_value)", + "semantic_text": null, + "referenced_pat_vars": [ + "p" + ], + "referenced_action_vars": [ + "op_value" + ], + "range": { + "start": 5831, + "end": 5857 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "expr.commit()", + "committed_root": "expr", + "referenced_vars": [ + "expr" + ], + "range": { + "start": 4171, + "end": 4184 + } + }, + { + "id": "seed_1", + "source_text": "expected.commit()", + "committed_root": "expected", + "referenced_vars": [ + "expected" + ], + "range": { + "start": 4255, + "end": 4272 + } + }, + { + "id": "seed_2", + "source_text": "expected_mul.commit()", + "committed_root": "expected_mul", + "referenced_vars": [ + "expected_mul" + ], + "range": { + "start": 4346, + "end": 4367 + } + } + ], + "display_templates": [], + "typst_templates": [ + { + "variant_name": "Const", + "template": "{num}", + "fields": [ + "num" + ] + }, + { + "variant_name": "Mul", + "template": "{l} * {r}", + "fields": [ + "l", + "r" + ] + }, + { + "variant_name": "Sub", + "template": "{l} - {r}", + "fields": [ + "l", + "r" + ] + }, + { + "variant_name": "Add", + "template": "{l} + {r}", + "fields": [ + "l", + "r" + ] + }, + { + "variant_name": "Div", + "template": "frac({l}, {r})", + "fields": [ + "l", + "r" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Const", + "precedence": 100 + }, + { + "variant_name": "Mul", + "precedence": 60 + }, + { + "variant_name": "Sub", + "precedence": 50 + }, + { + "variant_name": "Add", + "precedence": 50 + }, + { + "variant_name": "Div", + "precedence": 60 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "DebugConstPropMulPat", + "premises": [ + { + "target_id": "l", + "label": "l: Const", + "plain_source": "l", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ l $]" + }, + { + "target_id": "r", + "label": "r: Const", + "plain_source": "r", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ r $]" + }, + { + "target_id": "p", + "label": "p: Mul", + "plain_source": "l * r", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ l $] * #text(fill: rgb(\"#5F7A8A\"))[$ r $] $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "op_value", + "plain_source": "upright(\"cal\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ upright(\"cal\") $] $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "p", + "label": "p: Mul", + "plain_source": "l * r", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ l $] * #text(fill: rgb(\"#5F7A8A\"))[$ r $] $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "op_value", + "plain_source": "upright(\"cal\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ upright(\"cal\") $] $]" + } + } + ], + "formula_source": { + "plain": "frac(l \\ r \\ l * r, l * r arrow.r.double upright(\"cal\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ l $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ r $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ l $] * #text(fill: rgb(\"#5F7A8A\"))[$ r $] $], #text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ l $] * #text(fill: rgb(\"#5F7A8A\"))[$ r $] $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ #text(fill: rgb(\"#B86A5B\"))[$ upright(\"cal\") $] $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "examples_dsl_pattern_rs__27_5_MyTx_add_rule__this_rule__d7c059d880c95c72", + "display_name": "this rule", + "rule_name": "this rule", + "callee": "MyTx::add_rule", + "file": "examples/dsl_pattern.rs", + "offset": 540, + "line": 27, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 540, + "end": 973 + }, + "pattern_range": { + "start": 602, + "end": 774 + }, + "action_range": { + "start": 784, + "end": 966 + } + }, + "nodes": [ + { + "id": "l", + "kind": "query_leaf", + "dsl_type": "Expr", + "label": "l: Expr", + "range": { + "start": 619, + "end": 646 + }, + "inputs": [] + }, + { + "id": "r", + "kind": "query_leaf", + "dsl_type": "Expr", + "label": "r: Expr", + "range": { + "start": 659, + "end": 686 + }, + "inputs": [] + }, + { + "id": "a", + "kind": "query", + "dsl_type": "Mul", + "label": "a: Mul", + "range": { + "start": 699, + "end": 726 + }, + "inputs": [ + "l", + "r" + ] + } + ], + "edges": [ + { + "from": "a", + "to": "l", + "kind": "operand", + "index": 0 + }, + { + "from": "a", + "to": "r", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "l", + "r", + "a" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@877:915", + "bound_var": "mul", + "source_text": "ctx.insert_mul(pat.l_expr, pat.r_expr)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 877, + "end": 915 + } + }, + { + "id": "effect_1", + "effect_id": "effect@929:955", + "bound_var": null, + "source_text": "ctx.union(mul, pat.p_expr)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "mul" + ], + "range": { + "start": 929, + "end": 955 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "root.commit()", + "committed_root": "root", + "referenced_vars": [ + "root" + ], + "range": { + "start": 468, + "end": 481 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "this rule", + "premises": [ + { + "target_id": "a", + "label": "a: Mul", + "plain_source": "upright(\"Mul\")(l, r)", + "colored_source": "upright(\"Mul\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"Mul\")(l, r), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"Mul\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $]), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "examples_dynamic_action_trace_demo_rs__69_5_DemoTx_add_rule_with_hook__dynamic_action_trace_demo_rule__f4811fe58820fd83", + "display_name": "dynamic_action_trace_demo_rule", + "rule_name": "dynamic_action_trace_demo_rule", + "callee": "DemoTx::add_rule_with_hook", + "file": "examples/dynamic_action_trace_demo.rs", + "offset": 1713, + "line": 69, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 1713, + "end": 2644 + }, + "pattern_range": { + "start": 1808, + "end": 2202 + }, + "action_range": { + "start": 2212, + "end": 2609 + } + }, + "nodes": [ + { + "id": "l", + "kind": "query_leaf", + "dsl_type": "DemoExpr", + "label": "l: DemoExpr", + "range": { + "start": 1825, + "end": 1856 + }, + "inputs": [] + }, + { + "id": "r", + "kind": "query_leaf", + "dsl_type": "DemoExpr", + "label": "r: DemoExpr", + "range": { + "start": 1869, + "end": 1900 + }, + "inputs": [] + }, + { + "id": "expr", + "kind": "query", + "dsl_type": "TraceAdd", + "label": "expr: TraceAdd", + "range": { + "start": 1913, + "end": 1948 + }, + "inputs": [ + "l", + "r" + ] + }, + { + "id": "_root", + "kind": "query", + "dsl_type": "DemoRoot", + "label": "_root: DemoRoot", + "range": { + "start": 1961, + "end": 1996 + }, + "inputs": [ + "expr" + ] + } + ], + "edges": [ + { + "from": "expr", + "to": "l", + "kind": "operand", + "index": 0 + }, + { + "from": "expr", + "to": "r", + "kind": "operand", + "index": 1 + }, + { + "from": "_root", + "to": "expr", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "l", + "r", + "expr", + "l", + "r", + "expr" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@2281:2306", + "bound_var": "two", + "source_text": "ctx.insert_trace_const(2)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 2281, + "end": 2306 + } + }, + { + "id": "effect_1", + "effect_id": "effect@2334:2366", + "bound_var": "mul", + "source_text": "ctx.insert_trace_mul(pat.r, two)", + "semantic_text": null, + "referenced_pat_vars": [ + "r" + ], + "referenced_action_vars": [], + "range": { + "start": 2334, + "end": 2366 + } + }, + { + "id": "effect_2", + "effect_id": "effect@2384:2408", + "bound_var": null, + "source_text": "ctx.union(pat.expr, mul)", + "semantic_text": null, + "referenced_pat_vars": [ + "expr" + ], + "referenced_action_vars": [], + "range": { + "start": 2384, + "end": 2408 + } + }, + { + "id": "effect_3", + "effect_id": "effect@2457:2482", + "bound_var": "one", + "source_text": "ctx.insert_trace_const(1)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 2457, + "end": 2482 + } + }, + { + "id": "effect_4", + "effect_id": "effect@2510:2542", + "bound_var": "add", + "source_text": "ctx.insert_trace_add(pat.l, one)", + "semantic_text": null, + "referenced_pat_vars": [ + "l" + ], + "referenced_action_vars": [], + "range": { + "start": 2510, + "end": 2542 + } + }, + { + "id": "effect_5", + "effect_id": "effect@2560:2584", + "bound_var": null, + "source_text": "ctx.union(pat.expr, add)", + "semantic_text": null, + "referenced_pat_vars": [ + "expr" + ], + "referenced_action_vars": [], + "range": { + "start": 2560, + "end": 2584 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "root.commit()", + "committed_root": "root", + "referenced_vars": [ + "root" + ], + "range": { + "start": 1537, + "end": 1550 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "dynamic_action_trace_demo_rule", + "premises": [ + { + "target_id": "expr", + "label": "expr: TraceAdd", + "plain_source": "upright(\"TraceAdd\")(l, r)", + "colored_source": "upright(\"TraceAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])" + }, + { + "target_id": "expr", + "label": "expr: TraceAdd", + "plain_source": "upright(\"TraceAdd\")(l, r)", + "colored_source": "upright(\"TraceAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_1", + "label": "mul", + "plain_source": "upright(\"TraceMul\")(r, upright(\"TraceConst\")(2))", + "colored_source": "upright(\"TraceMul\")(#text(fill: rgb(\"#5F7A8A\"))[$ r $], upright(\"TraceConst\")(#text(fill: rgb(\"#B86A5B\"))[$ 2 $]))" + }, + { + "target_id": "effect:effect_4", + "label": "add", + "plain_source": "upright(\"TraceAdd\")(l, upright(\"TraceConst\")(1))", + "colored_source": "upright(\"TraceAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], upright(\"TraceConst\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $]))" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "expr", + "label": "expr: TraceAdd", + "plain_source": "upright(\"TraceAdd\")(l, r)", + "colored_source": "upright(\"TraceAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])" + }, + "to": { + "target_id": "effect:effect_1", + "label": "mul", + "plain_source": "upright(\"TraceMul\")(r, upright(\"TraceConst\")(2))", + "colored_source": "upright(\"TraceMul\")(#text(fill: rgb(\"#5F7A8A\"))[$ r $], upright(\"TraceConst\")(#text(fill: rgb(\"#B86A5B\"))[$ 2 $]))" + } + }, + { + "kind": "rewrite", + "id": "effect_5", + "from": { + "target_id": "expr", + "label": "expr: TraceAdd", + "plain_source": "upright(\"TraceAdd\")(l, r)", + "colored_source": "upright(\"TraceAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])" + }, + "to": { + "target_id": "effect:effect_4", + "label": "add", + "plain_source": "upright(\"TraceAdd\")(l, upright(\"TraceConst\")(1))", + "colored_source": "upright(\"TraceAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], upright(\"TraceConst\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $]))" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"TraceAdd\")(l, r) \\ upright(\"TraceAdd\")(l, r), upright(\"TraceAdd\")(l, r) arrow.r.double upright(\"TraceMul\")(r, upright(\"TraceConst\")(2)) \\ upright(\"TraceAdd\")(l, r) arrow.r.double upright(\"TraceAdd\")(l, upright(\"TraceConst\")(1))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"TraceAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $]) \\ upright(\"TraceAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $]), upright(\"TraceAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $]) arrow.r.double upright(\"TraceMul\")(#text(fill: rgb(\"#5F7A8A\"))[$ r $], upright(\"TraceConst\")(#text(fill: rgb(\"#B86A5B\"))[$ 2 $])) \\ upright(\"TraceAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $]) arrow.r.double upright(\"TraceAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], upright(\"TraceConst\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $]))) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "examples_dynamic_cost_rs__74_5_DynamicCostTx_add_rule__union_dynamic_cost_variants__d587ffaeda8eb2e7", + "display_name": "union_dynamic_cost_variants", + "rule_name": "union_dynamic_cost_variants", + "callee": "DynamicCostTx::add_rule", + "file": "examples/dynamic_cost.rs", + "offset": 1804, + "line": 74, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 1804, + "end": 2294 + }, + "pattern_range": { + "start": 1893, + "end": 2206 + }, + "action_range": { + "start": 2216, + "end": 2287 + } + }, + "nodes": [ + { + "id": "leaf", + "kind": "query", + "dsl_type": "Leaf", + "label": "leaf: Leaf", + "range": { + "start": 1910, + "end": 1935 + }, + "inputs": [] + }, + { + "id": "cheap", + "kind": "query", + "dsl_type": "CheapWrap", + "label": "cheap: CheapWrap", + "range": { + "start": 1948, + "end": 1984 + }, + "inputs": [ + "leaf" + ] + }, + { + "id": "expensive", + "kind": "query", + "dsl_type": "ExpensiveWrap", + "label": "expensive: ExpensiveWrap", + "range": { + "start": 1997, + "end": 2041 + }, + "inputs": [ + "leaf" + ] + } + ], + "edges": [ + { + "from": "cheap", + "to": "leaf", + "kind": "operand", + "index": 0 + }, + { + "from": "expensive", + "to": "leaf", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "cheap", + "expensive" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@2241:2276", + "bound_var": null, + "source_text": "ctx.union(pat.cheap, pat.expensive)", + "semantic_text": null, + "referenced_pat_vars": [ + "cheap", + "expensive" + ], + "referenced_action_vars": [], + "range": { + "start": 2241, + "end": 2276 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "leaf.commit()", + "committed_root": "leaf", + "referenced_vars": [ + "leaf" + ], + "range": { + "start": 1542, + "end": 1555 + } + }, + { + "id": "seed_1", + "source_text": "cheap.commit()", + "committed_root": "cheap", + "referenced_vars": [ + "cheap" + ], + "range": { + "start": 1618, + "end": 1632 + } + }, + { + "id": "seed_2", + "source_text": "expensive.commit()", + "committed_root": "expensive", + "referenced_vars": [ + "expensive" + ], + "range": { + "start": 1702, + "end": 1720 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "union_dynamic_cost_variants", + "premises": [ + { + "target_id": "cheap", + "label": "cheap: CheapWrap", + "plain_source": "upright(\"CheapWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"CheapWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + }, + { + "target_id": "expensive", + "label": "expensive: ExpensiveWrap", + "plain_source": "upright(\"ExpensiveWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"ExpensiveWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_0", + "from": { + "target_id": "cheap", + "label": "cheap: CheapWrap", + "plain_source": "upright(\"CheapWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"CheapWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + }, + "to": { + "target_id": "expensive", + "label": "expensive: ExpensiveWrap", + "plain_source": "upright(\"ExpensiveWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"ExpensiveWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"CheapWrap\")(upright(\"leaf\")) \\ upright(\"ExpensiveWrap\")(upright(\"leaf\")), upright(\"CheapWrap\")(upright(\"leaf\")) arrow.r.double upright(\"ExpensiveWrap\")(upright(\"leaf\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"CheapWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]) \\ upright(\"ExpensiveWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]), upright(\"CheapWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]) arrow.r.double upright(\"ExpensiveWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "examples_extract_value_with_cost_model_rs__63_5_ExtractCostTx_add_rule__union_wrappers_for_extract_cost_example__eb4f627cecb0115d", + "display_name": "union_wrappers_for_extract_cost_example", + "rule_name": "union_wrappers_for_extract_cost_example", + "callee": "ExtractCostTx::add_rule", + "file": "examples/extract_value_with_cost_model.rs", + "offset": 1572, + "line": 63, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 1572, + "end": 2099 + }, + "pattern_range": { + "start": 1673, + "end": 2002 + }, + "action_range": { + "start": 2012, + "end": 2092 + } + }, + "nodes": [ + { + "id": "leaf", + "kind": "query", + "dsl_type": "Leaf", + "label": "leaf: Leaf", + "range": { + "start": 1690, + "end": 1715 + }, + "inputs": [] + }, + { + "id": "default_wrap", + "kind": "query", + "dsl_type": "DefaultWrap", + "label": "default_wrap: DefaultWrap", + "range": { + "start": 1728, + "end": 1773 + }, + "inputs": [ + "leaf" + ] + }, + { + "id": "custom_wrap", + "kind": "query", + "dsl_type": "CustomWrap", + "label": "custom_wrap: CustomWrap", + "range": { + "start": 1786, + "end": 1829 + }, + "inputs": [ + "leaf" + ] + } + ], + "edges": [ + { + "from": "default_wrap", + "to": "leaf", + "kind": "operand", + "index": 0 + }, + { + "from": "custom_wrap", + "to": "leaf", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "default_wrap", + "custom_wrap" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@2037:2081", + "bound_var": null, + "source_text": "ctx.union(pat.default_wrap, pat.custom_wrap)", + "semantic_text": null, + "referenced_pat_vars": [ + "custom_wrap", + "default_wrap" + ], + "referenced_action_vars": [], + "range": { + "start": 2037, + "end": 2081 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "leaf.commit()", + "committed_root": "leaf", + "referenced_vars": [ + "leaf" + ], + "range": { + "start": 1281, + "end": 1294 + } + }, + { + "id": "seed_1", + "source_text": "default_wrap.commit()", + "committed_root": "default_wrap", + "referenced_vars": [ + "default_wrap" + ], + "range": { + "start": 1366, + "end": 1387 + } + }, + { + "id": "seed_2", + "source_text": "custom_wrap.commit()", + "committed_root": "custom_wrap", + "referenced_vars": [ + "custom_wrap" + ], + "range": { + "start": 1456, + "end": 1476 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "union_wrappers_for_extract_cost_example", + "premises": [ + { + "target_id": "default_wrap", + "label": "default_wrap: DefaultWrap", + "plain_source": "upright(\"DefaultWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"DefaultWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + }, + { + "target_id": "custom_wrap", + "label": "custom_wrap: CustomWrap", + "plain_source": "upright(\"CustomWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"CustomWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_0", + "from": { + "target_id": "default_wrap", + "label": "default_wrap: DefaultWrap", + "plain_source": "upright(\"DefaultWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"DefaultWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + }, + "to": { + "target_id": "custom_wrap", + "label": "custom_wrap: CustomWrap", + "plain_source": "upright(\"CustomWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"CustomWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"DefaultWrap\")(upright(\"leaf\")) \\ upright(\"CustomWrap\")(upright(\"leaf\")), upright(\"DefaultWrap\")(upright(\"leaf\")) arrow.r.double upright(\"CustomWrap\")(upright(\"leaf\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"DefaultWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]) \\ upright(\"CustomWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]), upright(\"DefaultWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]) arrow.r.double upright(\"CustomWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "examples_extract_value_with_dynamic_cost_rs__53_5_DynamicCostTx_add_rule__union_dynamic_cost_leaves__da1a68cf62cf1801", + "display_name": "union_dynamic_cost_leaves @ examples/extract_value_with_dynamic_cost.rs:53", + "rule_name": "union_dynamic_cost_leaves", + "callee": "DynamicCostTx::add_rule", + "file": "examples/extract_value_with_dynamic_cost.rs", + "offset": 1547, + "line": 53, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 1547, + "end": 2123 + }, + "pattern_range": { + "start": 1634, + "end": 1855 + }, + "action_range": { + "start": 1865, + "end": 2116 + } + }, + "nodes": [ + { + "id": "lhs", + "kind": "query", + "dsl_type": "Leaf", + "label": "lhs: Leaf", + "range": { + "start": 1651, + "end": 1675 + }, + "inputs": [] + }, + { + "id": "rhs", + "kind": "query", + "dsl_type": "Leaf", + "label": "rhs: Leaf", + "range": { + "start": 1688, + "end": 1712 + }, + "inputs": [] + } + ], + "edges": [], + "roots": [ + "lhs", + "rhs" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@2064:2091", + "bound_var": null, + "source_text": "ctx.union(pat.lhs, pat.rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "lhs", + "rhs" + ], + "referenced_action_vars": [], + "range": { + "start": 2064, + "end": 2091 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "expensive_leaf.commit()", + "committed_root": "expensive_leaf", + "referenced_vars": [ + "expensive_leaf" + ], + "range": { + "start": 1365, + "end": 1388 + } + }, + { + "id": "seed_1", + "source_text": "cheap_leaf.commit()", + "committed_root": "cheap_leaf", + "referenced_vars": [ + "cheap_leaf" + ], + "range": { + "start": 1446, + "end": 1465 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "union_dynamic_cost_leaves", + "premises": [ + { + "target_id": "lhs", + "label": "lhs: Leaf", + "plain_source": "upright(\"lhs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]" + }, + { + "target_id": "rhs", + "label": "rhs: Leaf", + "plain_source": "upright(\"rhs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_0", + "from": { + "target_id": "lhs", + "label": "lhs: Leaf", + "plain_source": "upright(\"lhs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]" + }, + "to": { + "target_id": "rhs", + "label": "rhs: Leaf", + "plain_source": "upright(\"rhs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"lhs\") \\ upright(\"rhs\"), upright(\"lhs\") arrow.r.double upright(\"rhs\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] arrow.r.double #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "examples_fib_rs__37_5_MyTx_add_rule__fib_seed__62426205774cab7d", + "display_name": "fib_seed", + "rule_name": "fib_seed", + "callee": "MyTx::add_rule", + "file": "examples/fib.rs", + "offset": 935, + "line": 37, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 935, + "end": 1184 + }, + "pattern_range": { + "start": 1001, + "end": 1082 + }, + "action_range": { + "start": 1092, + "end": 1177 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Unit" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@1118:1135", + "bound_var": null, + "source_text": "ctx.set_fib(0, 0)", + "semantic_text": "fib(0) = 0", + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 1118, + "end": 1135 + } + }, + { + "id": "effect_1", + "effect_id": "effect@1149:1166", + "bound_var": null, + "source_text": "ctx.set_fib(1, 1)", + "semantic_text": "fib(1) = 1", + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 1149, + "end": 1166 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "fib_seed", + "premises": [ + { + "target_id": "Unit", + "label": "Unit", + "plain_source": "upright(\"Unit\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "effect_0", + "plain_source": "upright(\"fib\")(0) = 0", + "colored_source": "upright(\"fib\")(#text(fill: rgb(\"#B86A5B\"))[$ 0 $]) = #text(fill: rgb(\"#B86A5B\"))[$ 0 $]" + } + }, + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "effect_1", + "plain_source": "upright(\"fib\")(1) = 1", + "colored_source": "upright(\"fib\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $]) = #text(fill: rgb(\"#B86A5B\"))[$ 1 $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"Unit\"), upright(\"fib\")(0) = 0 \\ upright(\"fib\")(1) = 1) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $], upright(\"fib\")(#text(fill: rgb(\"#B86A5B\"))[$ 0 $]) = #text(fill: rgb(\"#B86A5B\"))[$ 0 $] \\ upright(\"fib\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $]) = #text(fill: rgb(\"#B86A5B\"))[$ 1 $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "examples_fib_rs__51_5_MyTx_add_rule__fib_step__724f5612457664ce", + "display_name": "fib_step", + "rule_name": "fib_step", + "callee": "MyTx::add_rule", + "file": "examples/fib.rs", + "offset": 1245, + "line": 51, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 1245, + "end": 2013 + }, + "pattern_range": { + "start": 1311, + "end": 1809 + }, + "action_range": { + "start": 1819, + "end": 2006 + } + }, + "nodes": [ + { + "id": "f0", + "kind": "query", + "dsl_type": "fib", + "label": "f0: fib", + "range": { + "start": 1615, + "end": 1639 + }, + "inputs": [ + "x" + ] + }, + { + "id": "f1", + "kind": "query", + "dsl_type": "fib", + "label": "f1: fib", + "range": { + "start": 1652, + "end": 1677 + }, + "inputs": [ + "x1" + ] + } + ], + "edges": [ + { + "from": "f0", + "to": "x", + "kind": "operand", + "index": 0 + }, + { + "from": "f1", + "to": "x1", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "x", + "x1", + "x2", + "f0", + "f1" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "x1_constraint", + "resolved_text": "x1.handle().eq(&(x.handle() + (&1_i64).as_handle()))", + "semantic_text": "x1 == x + 1", + "referenced_vars": [ + "x", + "x1" + ], + "range": { + "start": 1746, + "end": 1759 + } + }, + { + "id": "constraint_1", + "source_text": "x2_constraint", + "resolved_text": "x2.handle().eq(&(x.handle() + (&2_i64).as_handle()))", + "semantic_text": "x2 == x + 2", + "referenced_vars": [ + "x", + "x2" + ], + "range": { + "start": 1785, + "end": 1798 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@1971:1995", + "bound_var": null, + "source_text": "ctx.set_fib(x2, f0 + f1)", + "semantic_text": "fib(x2) = f0 + f1", + "referenced_pat_vars": [ + "f0", + "f1", + "x2" + ], + "referenced_action_vars": [ + "f0", + "f1", + "x2" + ], + "range": { + "start": 1971, + "end": 1995 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "fib_step", + "premises": [ + { + "target_id": "f0", + "label": "f0: fib", + "plain_source": "upright(\"fib\")(x)", + "colored_source": "upright(\"fib\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $])" + }, + { + "target_id": "f1", + "label": "f1: fib", + "plain_source": "upright(\"fib\")(x_1)", + "colored_source": "upright(\"fib\")(#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $])" + } + ], + "side_conditions": [ + "x_1 == x + 1", + "x_2 == x + 2" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "effect_0", + "plain_source": "upright(\"fib\")(x_2) = f_0 + f_1", + "colored_source": "upright(\"fib\")(#text(fill: rgb(\"#5F7A8A\"))[$ x_2 $]) = #text(fill: rgb(\"#B86A5B\"))[$ f_0 + f_1 $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"fib\")(x) \\ upright(\"fib\")(x_1), upright(\"fib\")(x_2) = f_0 + f_1) quad upright(\"if\") quad x_1 == x + 1 \\ x_2 == x + 2", + "colored": "frac(upright(\"fib\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) \\ upright(\"fib\")(#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]), upright(\"fib\")(#text(fill: rgb(\"#5F7A8A\"))[$ x_2 $]) = #text(fill: rgb(\"#B86A5B\"))[$ f_0 + f_1 $]) quad upright(\"if\") quad x_1 == x + 1 \\ x_2 == x + 2" + } + } + } + }, + { + "id": "examples_func_read_complex_rs__35_5_MyTx_add_rule__seed_complex_output__a3302c56aa1fd961", + "display_name": "seed_complex_output", + "rule_name": "seed_complex_output", + "callee": "MyTx::add_rule", + "file": "examples/func_read_complex.rs", + "offset": 1079, + "line": 35, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 1079, + "end": 1335 + }, + "pattern_range": { + "start": 1156, + "end": 1237 + }, + "action_range": { + "start": 1247, + "end": 1328 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Unit" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@1278:1317", + "bound_var": null, + "source_text": "ctx.set_lead_to(add_1_2_key, three_key)", + "semantic_text": "lead_to(add_1_2_key) = three_key", + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 1278, + "end": 1317 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "add_1_2.commit()", + "committed_root": "add_1_2", + "referenced_vars": [ + "add_1_2" + ], + "range": { + "start": 619, + "end": 635 + } + }, + { + "id": "seed_1", + "source_text": "three.commit()", + "committed_root": "three", + "referenced_vars": [ + "three" + ], + "range": { + "start": 641, + "end": 655 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "seed_complex_output", + "premises": [ + { + "target_id": "Unit", + "label": "Unit", + "plain_source": "upright(\"Unit\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "effect_0", + "plain_source": "upright(\"lead_to\")(upright(\"add_1_2_key\")) = upright(\"three_key\")", + "colored_source": "upright(\"lead_to\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"add_1_2_key\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"three_key\") $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"Unit\"), upright(\"lead_to\")(upright(\"add_1_2_key\")) = upright(\"three_key\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $], upright(\"lead_to\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"add_1_2_key\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"three_key\") $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "examples_func_read_complex_rs__48_5_MyTx_add_rule__read_complex_output__45c918775f4541e2", + "display_name": "read_complex_output", + "rule_name": "read_complex_output", + "callee": "MyTx::add_rule", + "file": "examples/func_read_complex.rs", + "offset": 1402, + "line": 48, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 1402, + "end": 1903 + }, + "pattern_range": { + "start": 1474, + "end": 1799 + }, + "action_range": { + "start": 1809, + "end": 1896 + } + }, + "nodes": [ + { + "id": "add_1_2", + "kind": "query", + "dsl_type": "Add", + "label": "add_1_2: Add", + "range": { + "start": 1579, + "end": 1616 + }, + "inputs": [ + "one", + "two" + ] + }, + { + "id": "out", + "kind": "query", + "dsl_type": "LeadTo", + "label": "out: LeadTo", + "range": { + "start": 1629, + "end": 1663 + }, + "inputs": [ + "add_1_2" + ] + } + ], + "edges": [ + { + "from": "add_1_2", + "to": "one", + "kind": "operand", + "index": 0 + }, + { + "from": "add_1_2", + "to": "two", + "kind": "operand", + "index": 1 + }, + { + "from": "out", + "to": "add_1_2", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "out", + "out" + ], + "constraints": [], + "action_effects": [], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "add_1_2.commit()", + "committed_root": "add_1_2", + "referenced_vars": [ + "add_1_2" + ], + "range": { + "start": 619, + "end": 635 + } + }, + { + "id": "seed_1", + "source_text": "three.commit()", + "committed_root": "three", + "referenced_vars": [ + "three" + ], + "range": { + "start": 641, + "end": 655 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "read_complex_output", + "premises": [ + { + "target_id": "out", + "label": "out: LeadTo", + "plain_source": "upright(\"LeadTo\")(upright(\"Add\")(upright(\"one\"), upright(\"two\")))", + "colored_source": "upright(\"LeadTo\")(upright(\"Add\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"one\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"two\") $]))" + }, + { + "target_id": "out", + "label": "out: LeadTo", + "plain_source": "upright(\"LeadTo\")(upright(\"Add\")(upright(\"one\"), upright(\"two\")))", + "colored_source": "upright(\"LeadTo\")(upright(\"Add\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"one\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"two\") $]))" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"LeadTo\")(upright(\"Add\")(upright(\"one\"), upright(\"two\"))) \\ upright(\"LeadTo\")(upright(\"Add\")(upright(\"one\"), upright(\"two\"))), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"LeadTo\")(upright(\"Add\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"one\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"two\") $])) \\ upright(\"LeadTo\")(upright(\"Add\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"one\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"two\") $])), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "examples_pat_ref_rs__34_5_MyTx_add_rule__fnamadd_rule__40227b9457bde9d4", + "display_name": "fnamadd rule", + "rule_name": "fnamadd rule", + "callee": "MyTx::add_rule", + "file": "examples/pat_ref.rs", + "offset": 595, + "line": 34, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 595, + "end": 1368 + }, + "pattern_range": { + "start": 660, + "end": 1156 + }, + "action_range": { + "start": 1166, + "end": 1361 + } + }, + "nodes": [ + { + "id": "l", + "kind": "query", + "dsl_type": "Var", + "label": "l: Var", + "range": { + "start": 677, + "end": 698 + }, + "inputs": [] + }, + { + "id": "r", + "kind": "query", + "dsl_type": "Var", + "label": "r: Var", + "range": { + "start": 711, + "end": 732 + }, + "inputs": [] + }, + { + "id": "product", + "kind": "query", + "dsl_type": "Mul", + "label": "product: Mul", + "range": { + "start": 745, + "end": 778 + }, + "inputs": [ + "l", + "r" + ] + }, + { + "id": "neg", + "kind": "query", + "dsl_type": "Neg", + "label": "neg: Neg", + "range": { + "start": 791, + "end": 822 + }, + "inputs": [ + "product" + ] + }, + { + "id": "added", + "kind": "query", + "dsl_type": "Var", + "label": "added: Var", + "range": { + "start": 835, + "end": 860 + }, + "inputs": [] + }, + { + "id": "root", + "kind": "query", + "dsl_type": "Add", + "label": "root: Add", + "range": { + "start": 873, + "end": 909 + }, + "inputs": [ + "neg", + "added" + ] + } + ], + "edges": [ + { + "from": "product", + "to": "l", + "kind": "operand", + "index": 0 + }, + { + "from": "product", + "to": "r", + "kind": "operand", + "index": 1 + }, + { + "from": "neg", + "to": "product", + "kind": "operand", + "index": 0 + }, + { + "from": "root", + "to": "neg", + "kind": "operand", + "index": 0 + }, + { + "from": "root", + "to": "added", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "neg", + "l", + "r", + "added", + "root", + "neg", + "l", + "r", + "added", + "root" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@1265:1308", + "bound_var": "fnamadd", + "source_text": "ctx.insert_fnamadd(pat.l, pat.r, pat.added)", + "semantic_text": null, + "referenced_pat_vars": [ + "added", + "l", + "r" + ], + "referenced_action_vars": [], + "range": { + "start": 1265, + "end": 1308 + } + }, + { + "id": "effect_1", + "effect_id": "effect@1322:1350", + "bound_var": null, + "source_text": "ctx.union(fnamadd, pat.root)", + "semantic_text": null, + "referenced_pat_vars": [ + "root" + ], + "referenced_action_vars": [ + "fnamadd" + ], + "range": { + "start": 1322, + "end": 1350 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "fnamadd rule", + "premises": [ + { + "target_id": "neg", + "label": "neg: Neg", + "plain_source": "upright(\"Neg\")(upright(\"Mul\")(l, r))", + "colored_source": "upright(\"Neg\")(upright(\"Mul\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $]))" + }, + { + "target_id": "l", + "label": "l: Var", + "plain_source": "l", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ l $]" + }, + { + "target_id": "r", + "label": "r: Var", + "plain_source": "r", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ r $]" + }, + { + "target_id": "added", + "label": "added: Var", + "plain_source": "upright(\"added\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"added\") $]" + }, + { + "target_id": "root", + "label": "root: Add", + "plain_source": "upright(\"Add\")(upright(\"Neg\")(upright(\"Mul\")(l, r)), upright(\"added\"))", + "colored_source": "upright(\"Add\")(upright(\"Neg\")(upright(\"Mul\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"added\") $])" + }, + { + "target_id": "neg", + "label": "neg: Neg", + "plain_source": "upright(\"Neg\")(upright(\"Mul\")(l, r))", + "colored_source": "upright(\"Neg\")(upright(\"Mul\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $]))" + }, + { + "target_id": "l", + "label": "l: Var", + "plain_source": "l", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ l $]" + }, + { + "target_id": "r", + "label": "r: Var", + "plain_source": "r", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ r $]" + }, + { + "target_id": "added", + "label": "added: Var", + "plain_source": "upright(\"added\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"added\") $]" + }, + { + "target_id": "root", + "label": "root: Add", + "plain_source": "upright(\"Add\")(upright(\"Neg\")(upright(\"Mul\")(l, r)), upright(\"added\"))", + "colored_source": "upright(\"Add\")(upright(\"Neg\")(upright(\"Mul\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"added\") $])" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"Neg\")(upright(\"Mul\")(l, r)) \\ l \\ r \\ upright(\"added\") \\ upright(\"Add\")(upright(\"Neg\")(upright(\"Mul\")(l, r)), upright(\"added\")) \\ upright(\"Neg\")(upright(\"Mul\")(l, r)) \\ l \\ r \\ upright(\"added\") \\ upright(\"Add\")(upright(\"Neg\")(upright(\"Mul\")(l, r)), upright(\"added\")), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"Neg\")(upright(\"Mul\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])) \\ #text(fill: rgb(\"#5F7A8A\"))[$ l $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ r $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"added\") $] \\ upright(\"Add\")(upright(\"Neg\")(upright(\"Mul\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"added\") $]) \\ upright(\"Neg\")(upright(\"Mul\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])) \\ #text(fill: rgb(\"#5F7A8A\"))[$ l $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ r $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"added\") $] \\ upright(\"Add\")(upright(\"Neg\")(upright(\"Mul\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"added\") $]), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "examples_relation_rs__32_5_RelTx_add_rule__seed_path__51bc4d92f98c761a", + "display_name": "seed_path @ examples/relation.rs:32", + "rule_name": "seed_path", + "callee": "RelTx::add_rule", + "file": "examples/relation.rs", + "offset": 530, + "line": 32, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 530, + "end": 975 + }, + "pattern_range": { + "start": 593, + "end": 752 + }, + "action_range": { + "start": 762, + "end": 968 + } + }, + "nodes": [ + { + "id": "edge", + "kind": "query", + "dsl_type": "Edge", + "label": "edge: Edge", + "range": { + "start": 610, + "end": 635 + }, + "inputs": [] + } + ], + "edges": [], + "roots": [ + "edge" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@885:910", + "bound_var": null, + "source_text": "ctx.insert_path(src, dst)", + "semantic_text": null, + "referenced_pat_vars": [ + "edge" + ], + "referenced_action_vars": [ + "dst", + "src" + ], + "range": { + "start": 885, + "end": 910 + } + }, + { + "id": "effect_1", + "effect_id": "effect@924:957", + "bound_var": null, + "source_text": "ctx.set_path_mark(src, dst, true)", + "semantic_text": "path_mark(src, dst) = true", + "referenced_pat_vars": [ + "edge" + ], + "referenced_action_vars": [ + "dst", + "src" + ], + "range": { + "start": 924, + "end": 957 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "Edge::::insert(1, 2)", + "committed_root": "Edge::", + "referenced_vars": [], + "range": { + "start": 408, + "end": 435 + } + }, + { + "id": "seed_1", + "source_text": "Edge::::insert(2, 3)", + "committed_root": "Edge::", + "referenced_vars": [], + "range": { + "start": 441, + "end": 468 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "seed_path", + "premises": [ + { + "target_id": "edge", + "label": "edge: Edge", + "plain_source": "upright(\"edge\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"edge\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "effect_1", + "plain_source": "upright(\"path_mark\")(upright(\"src\"), upright(\"dst\")) = upright(\"true\")", + "colored_source": "upright(\"path_mark\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"src\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"dst\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"true\") $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"edge\"), upright(\"path_mark\")(upright(\"src\"), upright(\"dst\")) = upright(\"true\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"edge\") $], upright(\"path_mark\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"src\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"dst\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"true\") $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "examples_relation_rs__49_5_RelTx_add_rule__extend_path__be29ad8464e18c4b", + "display_name": "extend_path @ examples/relation.rs:49", + "rule_name": "extend_path", + "callee": "RelTx::add_rule", + "file": "examples/relation.rs", + "offset": 981, + "line": 49, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 981, + "end": 1599 + }, + "pattern_range": { + "start": 1046, + "end": 1376 + }, + "action_range": { + "start": 1386, + "end": 1592 + } + }, + "nodes": [ + { + "id": "path", + "kind": "query", + "dsl_type": "Path", + "label": "path: Path", + "range": { + "start": 1063, + "end": 1088 + }, + "inputs": [] + }, + { + "id": "edge", + "kind": "query", + "dsl_type": "Edge", + "label": "edge: Edge", + "range": { + "start": 1101, + "end": 1126 + }, + "inputs": [] + } + ], + "edges": [], + "roots": [ + "path", + "edge", + "path", + "edge" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "join", + "resolved_text": "path.handle_dst().eq(&edge.handle_src())", + "semantic_text": "path.dst == edge.src", + "referenced_vars": [ + "edge", + "path" + ], + "range": { + "start": 1361, + "end": 1365 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@1509:1534", + "bound_var": null, + "source_text": "ctx.insert_path(src, dst)", + "semantic_text": null, + "referenced_pat_vars": [ + "edge", + "path" + ], + "referenced_action_vars": [ + "dst", + "src" + ], + "range": { + "start": 1509, + "end": 1534 + } + }, + { + "id": "effect_1", + "effect_id": "effect@1548:1581", + "bound_var": null, + "source_text": "ctx.set_path_mark(src, dst, true)", + "semantic_text": "path_mark(src, dst) = true", + "referenced_pat_vars": [ + "edge", + "path" + ], + "referenced_action_vars": [ + "dst", + "src" + ], + "range": { + "start": 1548, + "end": 1581 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "Edge::::insert(1, 2)", + "committed_root": "Edge::", + "referenced_vars": [], + "range": { + "start": 408, + "end": 435 + } + }, + { + "id": "seed_1", + "source_text": "Edge::::insert(2, 3)", + "committed_root": "Edge::", + "referenced_vars": [], + "range": { + "start": 441, + "end": 468 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "extend_path", + "premises": [ + { + "target_id": "path", + "label": "path: Path", + "plain_source": "upright(\"path\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"path\") $]" + }, + { + "target_id": "edge", + "label": "edge: Edge", + "plain_source": "upright(\"edge\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"edge\") $]" + }, + { + "target_id": "path", + "label": "path: Path", + "plain_source": "upright(\"path\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"path\") $]" + }, + { + "target_id": "edge", + "label": "edge: Edge", + "plain_source": "upright(\"edge\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"edge\") $]" + } + ], + "side_conditions": [ + "upright(\"path.dst\") == upright(\"edge.src\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "effect_1", + "plain_source": "upright(\"path_mark\")(upright(\"src\"), upright(\"dst\")) = upright(\"true\")", + "colored_source": "upright(\"path_mark\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"src\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"dst\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"true\") $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"path\") \\ upright(\"edge\") \\ upright(\"path\") \\ upright(\"edge\"), upright(\"path_mark\")(upright(\"src\"), upright(\"dst\")) = upright(\"true\")) quad upright(\"if\") quad upright(\"path.dst\") == upright(\"edge.src\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"path\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"edge\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"path\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"edge\") $], upright(\"path_mark\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"src\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"dst\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"true\") $]) quad upright(\"if\") quad upright(\"path.dst\") == upright(\"edge.src\")" + } + } + } + }, + { + "id": "examples_relation_transfer_story_rs__52_5_OwnershipTx_add_rule__seed_story__52eeb22b811e8f94", + "display_name": "seed_story @ examples/relation_transfer_story.rs:52", + "rule_name": "seed_story", + "callee": "OwnershipTx::add_rule", + "file": "examples/relation_transfer_story.rs", + "offset": 1074, + "line": 52, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 1074, + "end": 1559 + }, + "pattern_range": { + "start": 1144, + "end": 1225 + }, + "action_range": { + "start": 1235, + "end": 1552 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Unit" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@1270:1296", + "bound_var": "alice", + "source_text": "ctx.insert_human(ALICE_ID)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 1270, + "end": 1296 + } + }, + { + "id": "effect_1", + "effect_id": "effect@1320:1344", + "bound_var": "bob", + "source_text": "ctx.insert_human(BOB_ID)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 1320, + "end": 1344 + } + }, + { + "id": "effect_2", + "effect_id": "effect@1370:1396", + "bound_var": "carol", + "source_text": "ctx.insert_human(CAROL_ID)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 1370, + "end": 1396 + } + }, + { + "id": "effect_3", + "effect_id": "effect@1410:1441", + "bound_var": null, + "source_text": "ctx.insert_owns(alice, RING_ID)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "alice" + ], + "range": { + "start": 1410, + "end": 1441 + } + }, + { + "id": "effect_4", + "effect_id": "effect@1455:1486", + "bound_var": null, + "source_text": "ctx.insert_owns(carol, BOOK_ID)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "carol" + ], + "range": { + "start": 1455, + "end": 1486 + } + }, + { + "id": "effect_5", + "effect_id": "effect@1500:1541", + "bound_var": null, + "source_text": "ctx.insert_transfer_request(bob, RING_ID)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "bob" + ], + "range": { + "start": 1500, + "end": 1541 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "seed_story", + "premises": [ + { + "target_id": "Unit", + "label": "Unit", + "plain_source": "upright(\"Unit\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"Unit\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "examples_relation_transfer_story_rs__68_5_OwnershipTx_add_rule__mark_ownership__249f30e672b1b0a3", + "display_name": "mark_ownership @ examples/relation_transfer_story.rs:68", + "rule_name": "mark_ownership", + "callee": "OwnershipTx::add_rule", + "file": "examples/relation_transfer_story.rs", + "offset": 1565, + "line": 68, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 1565, + "end": 2113 + }, + "pattern_range": { + "start": 1639, + "end": 1902 + }, + "action_range": { + "start": 1912, + "end": 2106 + } + }, + "nodes": [ + { + "id": "owner", + "kind": "query", + "dsl_type": "Human", + "label": "owner: Human", + "range": { + "start": 1656, + "end": 1683 + }, + "inputs": [] + }, + { + "id": "owns", + "kind": "query", + "dsl_type": "Owns", + "label": "owns: Owns", + "range": { + "start": 1696, + "end": 1727 + }, + "inputs": [ + "owner" + ] + } + ], + "edges": [ + { + "from": "owns", + "to": "owner", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "owns", + "owner", + "owns", + "owner" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@2048:2095", + "bound_var": null, + "source_text": "ctx.set_ownership_seen(owner_id, item_id, true)", + "semantic_text": "ownership_seen(owner_id, item_id) = true", + "referenced_pat_vars": [ + "owner", + "owns" + ], + "referenced_action_vars": [ + "item_id", + "owner_id" + ], + "range": { + "start": 2048, + "end": 2095 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "mark_ownership", + "premises": [ + { + "target_id": "owns", + "label": "owns: Owns", + "plain_source": "upright(\"Owns\")(upright(\"owner\"))", + "colored_source": "upright(\"Owns\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"owner\") $])" + }, + { + "target_id": "owner", + "label": "owner: Human", + "plain_source": "upright(\"owner\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"owner\") $]" + }, + { + "target_id": "owns", + "label": "owns: Owns", + "plain_source": "upright(\"Owns\")(upright(\"owner\"))", + "colored_source": "upright(\"Owns\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"owner\") $])" + }, + { + "target_id": "owner", + "label": "owner: Human", + "plain_source": "upright(\"owner\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"owner\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "effect_0", + "plain_source": "upright(\"ownership_seen\")(upright(\"owner_id\"), upright(\"item_id\")) = upright(\"true\")", + "colored_source": "upright(\"ownership_seen\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"owner_id\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"item_id\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"true\") $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"Owns\")(upright(\"owner\")) \\ upright(\"owner\") \\ upright(\"Owns\")(upright(\"owner\")) \\ upright(\"owner\"), upright(\"ownership_seen\")(upright(\"owner_id\"), upright(\"item_id\")) = upright(\"true\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"Owns\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"owner\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"owner\") $] \\ upright(\"Owns\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"owner\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"owner\") $], upright(\"ownership_seen\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"owner_id\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"item_id\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"true\") $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "examples_relation_transfer_story_rs__87_5_OwnershipTx_add_rule__apply_transfer__3e80815eb6e54347", + "display_name": "apply_transfer @ examples/relation_transfer_story.rs:87", + "rule_name": "apply_transfer", + "callee": "OwnershipTx::add_rule", + "file": "examples/relation_transfer_story.rs", + "offset": 2119, + "line": 87, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 2119, + "end": 3443 + }, + "pattern_range": { + "start": 2193, + "end": 2925 + }, + "action_range": { + "start": 2935, + "end": 3436 + } + }, + "nodes": [ + { + "id": "current_owner", + "kind": "query", + "dsl_type": "Human", + "label": "current_owner: Human", + "range": { + "start": 2210, + "end": 2245 + }, + "inputs": [] + }, + { + "id": "owns", + "kind": "query", + "dsl_type": "Owns", + "label": "owns: Owns", + "range": { + "start": 2258, + "end": 2297 + }, + "inputs": [ + "current_owner" + ] + }, + { + "id": "new_owner", + "kind": "query", + "dsl_type": "Human", + "label": "new_owner: Human", + "range": { + "start": 2310, + "end": 2341 + }, + "inputs": [] + }, + { + "id": "request", + "kind": "query", + "dsl_type": "TransferRequest", + "label": "request: TransferRequest", + "range": { + "start": 2354, + "end": 2403 + }, + "inputs": [ + "new_owner" + ] + } + ], + "edges": [ + { + "from": "owns", + "to": "current_owner", + "kind": "operand", + "index": 0 + }, + { + "from": "request", + "to": "new_owner", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "owns", + "current_owner", + "request", + "new_owner", + "owns", + "current_owner", + "request", + "new_owner" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "same_item", + "resolved_text": "owns.handle_item_id().eq(&request.handle_item_id())", + "semantic_text": "owns.item_id == request.item_id", + "referenced_vars": [ + "owns", + "request" + ], + "range": { + "start": 2866, + "end": 2875 + } + }, + { + "id": "constraint_1", + "source_text": "owner_changes", + "resolved_text": "current_owner.handle().ne(&new_owner.handle())", + "semantic_text": "current_owner != new_owner", + "referenced_vars": [ + "current_owner", + "new_owner" + ], + "range": { + "start": 2901, + "end": 2914 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@3305:3344", + "bound_var": null, + "source_text": "ctx.insert_owns(pat.new_owner, item_id)", + "semantic_text": null, + "referenced_pat_vars": [ + "new_owner", + "owns" + ], + "referenced_action_vars": [ + "item_id" + ], + "range": { + "start": 3305, + "end": 3344 + } + }, + { + "id": "effect_1", + "effect_id": "effect@3358:3425", + "bound_var": null, + "source_text": "ctx.set_transfer_applied(item_id, from_owner_id, to_owner_id, true)", + "semantic_text": "transfer_applied(item_id, from_owner_id, to_owner_id) = true", + "referenced_pat_vars": [ + "current_owner", + "new_owner", + "owns" + ], + "referenced_action_vars": [ + "from_owner_id", + "item_id", + "to_owner_id" + ], + "range": { + "start": 3358, + "end": 3425 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "apply_transfer", + "premises": [ + { + "target_id": "owns", + "label": "owns: Owns", + "plain_source": "upright(\"Owns\")(upright(\"current_owner\"))", + "colored_source": "upright(\"Owns\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"current_owner\") $])" + }, + { + "target_id": "current_owner", + "label": "current_owner: Human", + "plain_source": "upright(\"current_owner\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"current_owner\") $]" + }, + { + "target_id": "request", + "label": "request: TransferRequest", + "plain_source": "upright(\"TransferRequest\")(upright(\"new_owner\"))", + "colored_source": "upright(\"TransferRequest\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_owner\") $])" + }, + { + "target_id": "new_owner", + "label": "new_owner: Human", + "plain_source": "upright(\"new_owner\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_owner\") $]" + }, + { + "target_id": "owns", + "label": "owns: Owns", + "plain_source": "upright(\"Owns\")(upright(\"current_owner\"))", + "colored_source": "upright(\"Owns\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"current_owner\") $])" + }, + { + "target_id": "current_owner", + "label": "current_owner: Human", + "plain_source": "upright(\"current_owner\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"current_owner\") $]" + }, + { + "target_id": "request", + "label": "request: TransferRequest", + "plain_source": "upright(\"TransferRequest\")(upright(\"new_owner\"))", + "colored_source": "upright(\"TransferRequest\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_owner\") $])" + }, + { + "target_id": "new_owner", + "label": "new_owner: Human", + "plain_source": "upright(\"new_owner\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_owner\") $]" + } + ], + "side_conditions": [ + "upright(\"owns.item_id\") == upright(\"request.item_id\")", + "upright(\"current_owner\") != upright(\"new_owner\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "effect_1", + "plain_source": "upright(\"transfer_applied\")(upright(\"item_id\"), upright(\"from_owner_id\"), upright(\"to_owner_id\")) = upright(\"true\")", + "colored_source": "upright(\"transfer_applied\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"item_id\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"from_owner_id\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"to_owner_id\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"true\") $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"Owns\")(upright(\"current_owner\")) \\ upright(\"current_owner\") \\ upright(\"TransferRequest\")(upright(\"new_owner\")) \\ upright(\"new_owner\") \\ upright(\"Owns\")(upright(\"current_owner\")) \\ upright(\"current_owner\") \\ upright(\"TransferRequest\")(upright(\"new_owner\")) \\ upright(\"new_owner\"), upright(\"transfer_applied\")(upright(\"item_id\"), upright(\"from_owner_id\"), upright(\"to_owner_id\")) = upright(\"true\")) quad upright(\"if\") quad upright(\"owns.item_id\") == upright(\"request.item_id\") \\ upright(\"current_owner\") != upright(\"new_owner\")", + "colored": "frac(upright(\"Owns\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"current_owner\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"current_owner\") $] \\ upright(\"TransferRequest\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_owner\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_owner\") $] \\ upright(\"Owns\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"current_owner\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"current_owner\") $] \\ upright(\"TransferRequest\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_owner\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_owner\") $], upright(\"transfer_applied\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"item_id\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"from_owner_id\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"to_owner_id\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"true\") $]) quad upright(\"if\") quad upright(\"owns.item_id\") == upright(\"request.item_id\") \\ upright(\"current_owner\") != upright(\"new_owner\")" + } + } + } + }, + { + "id": "examples_rustsat_common_subexpr_rs__37_9_RustsatCseTx_add_rule__union_common_subexpr_roots_for_rustsat_demo__204f914d90747b44", + "display_name": "union_common_subexpr_roots_for_rustsat_demo", + "rule_name": "union_common_subexpr_roots_for_rustsat_demo", + "callee": "RustsatCseTx::add_rule", + "file": "examples/rustsat_common_subexpr.rs", + "offset": 1257, + "line": 37, + "column": 9, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 1257, + "end": 2570 + }, + "pattern_range": { + "start": 1373, + "end": 2183 + }, + "action_range": { + "start": 2197, + "end": 2559 + } + }, + "nodes": [ + { + "id": "shared_leaf", + "kind": "query", + "dsl_type": "CLeaf", + "label": "shared_leaf: CLeaf", + "range": { + "start": 1394, + "end": 1427 + }, + "inputs": [] + }, + { + "id": "shared_l1", + "kind": "query", + "dsl_type": "CInc", + "label": "shared_l1: CInc", + "range": { + "start": 1444, + "end": 1486 + }, + "inputs": [ + "shared_leaf" + ] + }, + { + "id": "shared", + "kind": "query", + "dsl_type": "CInc", + "label": "shared: CInc", + "range": { + "start": 1503, + "end": 1540 + }, + "inputs": [ + "shared_l1" + ] + }, + { + "id": "shared_root", + "kind": "query", + "dsl_type": "CPair", + "label": "shared_root: CPair", + "range": { + "start": 1557, + "end": 1606 + }, + "inputs": [ + "shared", + "shared" + ] + }, + { + "id": "left_leaf", + "kind": "query", + "dsl_type": "CLeaf", + "label": "left_leaf: CLeaf", + "range": { + "start": 1624, + "end": 1655 + }, + "inputs": [] + }, + { + "id": "left", + "kind": "query", + "dsl_type": "CInc", + "label": "left: CInc", + "range": { + "start": 1672, + "end": 1707 + }, + "inputs": [ + "left_leaf" + ] + }, + { + "id": "right_leaf", + "kind": "query", + "dsl_type": "CLeaf", + "label": "right_leaf: CLeaf", + "range": { + "start": 1724, + "end": 1756 + }, + "inputs": [] + }, + { + "id": "right", + "kind": "query", + "dsl_type": "CInc", + "label": "right: CInc", + "range": { + "start": 1773, + "end": 1810 + }, + "inputs": [ + "right_leaf" + ] + }, + { + "id": "duplicated_root", + "kind": "query", + "dsl_type": "CPair", + "label": "duplicated_root: CPair", + "range": { + "start": 1827, + "end": 1877 + }, + "inputs": [ + "left", + "right" + ] + } + ], + "edges": [ + { + "from": "shared_l1", + "to": "shared_leaf", + "kind": "operand", + "index": 0 + }, + { + "from": "shared", + "to": "shared_l1", + "kind": "operand", + "index": 0 + }, + { + "from": "shared_root", + "to": "shared", + "kind": "operand", + "index": 0 + }, + { + "from": "shared_root", + "to": "shared", + "kind": "operand", + "index": 1 + }, + { + "from": "left", + "to": "left_leaf", + "kind": "operand", + "index": 0 + }, + { + "from": "right", + "to": "right_leaf", + "kind": "operand", + "index": 0 + }, + { + "from": "duplicated_root", + "to": "left", + "kind": "operand", + "index": 0 + }, + { + "from": "duplicated_root", + "to": "right", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "shared_leaf", + "shared_root", + "left_leaf", + "right_leaf", + "duplicated_root" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@2479:2526", + "bound_var": null, + "source_text": "ctx.union(pat.shared_root, pat.duplicated_root)", + "semantic_text": null, + "referenced_pat_vars": [ + "duplicated_root", + "shared_root" + ], + "referenced_action_vars": [], + "range": { + "start": 2479, + "end": 2526 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "shared_root.commit()", + "committed_root": "shared_root", + "referenced_vars": [ + "shared_root" + ], + "range": { + "start": 793, + "end": 813 + } + }, + { + "id": "seed_1", + "source_text": "duplicated_root.commit()", + "committed_root": "duplicated_root", + "referenced_vars": [ + "duplicated_root" + ], + "range": { + "start": 1126, + "end": 1150 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "union_common_subexpr_roots_for_rustsat_demo", + "premises": [ + { + "target_id": "shared_leaf", + "label": "shared_leaf: CLeaf", + "plain_source": "upright(\"shared_leaf\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared_leaf\") $]" + }, + { + "target_id": "shared_root", + "label": "shared_root: CPair", + "plain_source": "upright(\"CPair\")(upright(\"shared\"), upright(\"shared\"))", + "colored_source": "upright(\"CPair\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $])" + }, + { + "target_id": "left_leaf", + "label": "left_leaf: CLeaf", + "plain_source": "upright(\"left_leaf\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left_leaf\") $]" + }, + { + "target_id": "right_leaf", + "label": "right_leaf: CLeaf", + "plain_source": "upright(\"right_leaf\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right_leaf\") $]" + }, + { + "target_id": "duplicated_root", + "label": "duplicated_root: CPair", + "plain_source": "upright(\"CPair\")(upright(\"CInc\")(upright(\"left_leaf\")), upright(\"CInc\")(upright(\"right_leaf\")))", + "colored_source": "upright(\"CPair\")(upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left_leaf\") $]), upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right_leaf\") $]))" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_0", + "from": { + "target_id": "shared_root", + "label": "shared_root: CPair", + "plain_source": "upright(\"CPair\")(upright(\"shared\"), upright(\"shared\"))", + "colored_source": "upright(\"CPair\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $])" + }, + "to": { + "target_id": "duplicated_root", + "label": "duplicated_root: CPair", + "plain_source": "upright(\"CPair\")(upright(\"CInc\")(upright(\"left_leaf\")), upright(\"CInc\")(upright(\"right_leaf\")))", + "colored_source": "upright(\"CPair\")(upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left_leaf\") $]), upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right_leaf\") $]))" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"shared_leaf\") \\ upright(\"CPair\")(upright(\"shared\"), upright(\"shared\")) \\ upright(\"left_leaf\") \\ upright(\"right_leaf\") \\ upright(\"CPair\")(upright(\"CInc\")(upright(\"left_leaf\")), upright(\"CInc\")(upright(\"right_leaf\"))), upright(\"CPair\")(upright(\"shared\"), upright(\"shared\")) arrow.r.double upright(\"CPair\")(upright(\"CInc\")(upright(\"left_leaf\")), upright(\"CInc\")(upright(\"right_leaf\")))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared_leaf\") $] \\ upright(\"CPair\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left_leaf\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right_leaf\") $] \\ upright(\"CPair\")(upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left_leaf\") $]), upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right_leaf\") $])), upright(\"CPair\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $]) arrow.r.double upright(\"CPair\")(upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left_leaf\") $]), upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right_leaf\") $]))) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "examples_rustsat_optimize_expression_rs__38_9_RustsatDemoTx_add_rule__union_wrapper_variants_for_rustsat_demo__a7373731a276e6ed", + "display_name": "union_wrapper_variants_for_rustsat_demo", + "rule_name": "union_wrapper_variants_for_rustsat_demo", + "callee": "RustsatDemoTx::add_rule", + "file": "examples/rustsat_optimize_expression.rs", + "offset": 984, + "line": 38, + "column": 9, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 984, + "end": 1550 + }, + "pattern_range": { + "start": 1097, + "end": 1446 + }, + "action_range": { + "start": 1460, + "end": 1539 + } + }, + "nodes": [ + { + "id": "leaf", + "kind": "query", + "dsl_type": "Leaf", + "label": "leaf: Leaf", + "range": { + "start": 1118, + "end": 1143 + }, + "inputs": [] + }, + { + "id": "cheap", + "kind": "query", + "dsl_type": "CheapWrap", + "label": "cheap: CheapWrap", + "range": { + "start": 1160, + "end": 1196 + }, + "inputs": [ + "leaf" + ] + }, + { + "id": "expensive", + "kind": "query", + "dsl_type": "ExpensiveWrap", + "label": "expensive: ExpensiveWrap", + "range": { + "start": 1213, + "end": 1257 + }, + "inputs": [ + "leaf" + ] + } + ], + "edges": [ + { + "from": "cheap", + "to": "leaf", + "kind": "operand", + "index": 0 + }, + { + "from": "expensive", + "to": "leaf", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "cheap", + "expensive" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@1489:1524", + "bound_var": null, + "source_text": "ctx.union(pat.cheap, pat.expensive)", + "semantic_text": null, + "referenced_pat_vars": [ + "cheap", + "expensive" + ], + "referenced_action_vars": [], + "range": { + "start": 1489, + "end": 1524 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "cheap.commit()", + "committed_root": "cheap", + "referenced_vars": [ + "cheap" + ], + "range": { + "start": 770, + "end": 784 + } + }, + { + "id": "seed_1", + "source_text": "expensive.commit()", + "committed_root": "expensive", + "referenced_vars": [ + "expensive" + ], + "range": { + "start": 862, + "end": 880 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "union_wrapper_variants_for_rustsat_demo", + "premises": [ + { + "target_id": "cheap", + "label": "cheap: CheapWrap", + "plain_source": "upright(\"CheapWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"CheapWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + }, + { + "target_id": "expensive", + "label": "expensive: ExpensiveWrap", + "plain_source": "upright(\"ExpensiveWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"ExpensiveWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_0", + "from": { + "target_id": "cheap", + "label": "cheap: CheapWrap", + "plain_source": "upright(\"CheapWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"CheapWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + }, + "to": { + "target_id": "expensive", + "label": "expensive: ExpensiveWrap", + "plain_source": "upright(\"ExpensiveWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"ExpensiveWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"CheapWrap\")(upright(\"leaf\")) \\ upright(\"ExpensiveWrap\")(upright(\"leaf\")), upright(\"CheapWrap\")(upright(\"leaf\")) arrow.r.double upright(\"ExpensiveWrap\")(upright(\"leaf\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"CheapWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]) \\ upright(\"ExpensiveWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]), upright(\"CheapWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]) arrow.r.double upright(\"ExpensiveWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "examples_sample_trace_json_rs__32_5_SampleTx_add_rule_with_hook__sample_trace_json_rule__b9fbbf46d887abca", + "display_name": "sample_trace_json_rule", + "rule_name": "sample_trace_json_rule", + "callee": "SampleTx::add_rule_with_hook", + "file": "examples/sample_trace_json.rs", + "offset": 787, + "line": 32, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 787, + "end": 1336 + }, + "pattern_range": { + "start": 876, + "end": 1123 + }, + "action_range": { + "start": 1133, + "end": 1301 + } + }, + "nodes": [ + { + "id": "expr", + "kind": "query_leaf", + "dsl_type": "SampleExpr", + "label": "expr: SampleExpr", + "range": { + "start": 893, + "end": 929 + }, + "inputs": [] + }, + { + "id": "_root", + "kind": "query", + "dsl_type": "SampleRoot", + "label": "_root: SampleRoot", + "range": { + "start": 942, + "end": 979 + }, + "inputs": [ + "expr" + ] + } + ], + "edges": [ + { + "from": "_root", + "to": "expr", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "expr", + "expr" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@1168:1193", + "bound_var": "one", + "source_text": "ctx.insert_trace_const(1)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 1168, + "end": 1193 + } + }, + { + "id": "effect_1", + "effect_id": "effect@1217:1252", + "bound_var": "sum", + "source_text": "ctx.insert_trace_add(pat.expr, one)", + "semantic_text": null, + "referenced_pat_vars": [ + "expr" + ], + "referenced_action_vars": [ + "one" + ], + "range": { + "start": 1217, + "end": 1252 + } + }, + { + "id": "effect_2", + "effect_id": "effect@1266:1290", + "bound_var": null, + "source_text": "ctx.union(pat.expr, sum)", + "semantic_text": null, + "referenced_pat_vars": [ + "expr" + ], + "referenced_action_vars": [ + "sum" + ], + "range": { + "start": 1266, + "end": 1290 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "root.commit()", + "committed_root": "root", + "referenced_vars": [ + "root" + ], + "range": { + "start": 617, + "end": 630 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "sample_trace_json_rule", + "premises": [ + { + "target_id": "expr", + "label": "expr: SampleExpr", + "plain_source": "upright(\"expr\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $]" + }, + { + "target_id": "expr", + "label": "expr: SampleExpr", + "plain_source": "upright(\"expr\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "one", + "plain_source": "upright(\"TraceConst\")(1)", + "colored_source": "upright(\"TraceConst\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $])" + }, + { + "target_id": "effect:effect_1", + "label": "sum", + "plain_source": "upright(\"TraceAdd\")(upright(\"expr\"), upright(\"TraceConst\")(1))", + "colored_source": "upright(\"TraceAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $], upright(\"TraceConst\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $]))" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "expr", + "label": "expr: SampleExpr", + "plain_source": "upright(\"expr\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $]" + }, + "to": { + "target_id": "effect:effect_1", + "label": "sum", + "plain_source": "upright(\"TraceAdd\")(upright(\"expr\"), upright(\"TraceConst\")(1))", + "colored_source": "upright(\"TraceAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $], upright(\"TraceConst\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $]))" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"expr\") \\ upright(\"expr\"), upright(\"expr\") arrow.r.double upright(\"TraceAdd\")(upright(\"expr\"), upright(\"TraceConst\")(1))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $] arrow.r.double upright(\"TraceAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $], upright(\"TraceConst\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $]))) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "examples_timestamp_filter_rs__33_5_TsTx_add_rule__timestamp_filtered_recent_leaf__218beadcf8ad44fa", + "display_name": "timestamp_filtered_recent_leaf @ examples/timestamp_filter.rs:33", + "rule_name": "timestamp_filtered_recent_leaf", + "callee": "TsTx::add_rule", + "file": "examples/timestamp_filter.rs", + "offset": 700, + "line": 33, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 700, + "end": 1149 + }, + "pattern_range": { + "start": 783, + "end": 1026 + }, + "action_range": { + "start": 1036, + "end": 1142 + } + }, + "nodes": [ + { + "id": "leaf", + "kind": "query", + "dsl_type": "Leaf", + "label": "leaf: Leaf", + "range": { + "start": 805, + "end": 830 + }, + "inputs": [] + } + ], + "edges": [], + "roots": [ + "leaf" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@1106:1131", + "bound_var": null, + "source_text": "ctx.insert_recent_leaf(n)", + "semantic_text": null, + "referenced_pat_vars": [ + "leaf" + ], + "referenced_action_vars": [ + "n" + ], + "range": { + "start": 1106, + "end": 1131 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "old_leaf.commit()", + "committed_root": "old_leaf", + "referenced_vars": [ + "old_leaf" + ], + "range": { + "start": 425, + "end": 442 + } + }, + { + "id": "seed_1", + "source_text": "new_leaf.commit()", + "committed_root": "new_leaf", + "referenced_vars": [ + "new_leaf" + ], + "range": { + "start": 605, + "end": 622 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "timestamp_filtered_recent_leaf", + "premises": [ + { + "target_id": "leaf", + "label": "leaf: Leaf", + "plain_source": "upright(\"leaf\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"leaf\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_benchmarks_nncase_clamp_microbenchmark_rs__218_5_NncaseClampTx_add_rule__relu_to_clamp__9f8bdb08cb782e6b", + "display_name": "relu_to_clamp", + "rule_name": "relu_to_clamp", + "callee": "NncaseClampTx::add_rule", + "file": "src/benchmarks/nncase_clamp_microbenchmark.rs", + "offset": 6135, + "line": 218, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 6135, + "end": 6618 + }, + "pattern_range": { + "start": 6205, + "end": 6481 + }, + "action_range": { + "start": 6491, + "end": 6611 + } + }, + "nodes": [ + { + "id": "inner", + "kind": "query_leaf", + "dsl_type": "ClampExpr", + "label": "inner: ClampExpr", + "range": { + "start": 6222, + "end": 6258 + }, + "inputs": [] + }, + { + "id": "relu", + "kind": "query", + "dsl_type": "Relu", + "label": "relu: Relu", + "range": { + "start": 6271, + "end": 6302 + }, + "inputs": [ + "inner" + ] + } + ], + "edges": [ + { + "from": "relu", + "to": "inner", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "inner", + "relu", + "inner", + "relu" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@6526:6562", + "bound_var": "rhs", + "source_text": "ctx.insert_clamp_zero_inf(pat.inner)", + "semantic_text": null, + "referenced_pat_vars": [ + "inner" + ], + "referenced_action_vars": [], + "range": { + "start": 6526, + "end": 6562 + } + }, + { + "id": "effect_1", + "effect_id": "effect@6576:6600", + "bound_var": null, + "source_text": "ctx.union(pat.relu, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "relu" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 6576, + "end": 6600 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "Input", + "template": "{name}", + "fields": [ + "name" + ] + } + ], + "typst_templates": [ + { + "variant_name": "Input", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Weight", + "template": "w_({name})", + "fields": [ + "name" + ] + }, + { + "variant_name": "Conv2D", + "template": "({input} * {weight})", + "fields": [ + "input", + "weight" + ] + }, + { + "variant_name": "Relu", + "template": "|{inner}|", + "fields": [ + "inner" + ] + }, + { + "variant_name": "Relu6", + "template": "|{inner}|_6", + "fields": [ + "inner" + ] + }, + { + "variant_name": "ClampZeroInf", + "template": "[{inner}]", + "fields": [ + "inner" + ] + }, + { + "variant_name": "ClampZeroSix", + "template": "[{inner}]_6", + "fields": [ + "inner" + ] + }, + { + "variant_name": "FusedConv2D", + "template": "(({input} * {weight}))_f", + "fields": [ + "input", + "weight" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Input", + "precedence": 100 + }, + { + "variant_name": "Weight", + "precedence": 100 + }, + { + "variant_name": "Conv2D", + "precedence": 60 + }, + { + "variant_name": "Relu", + "precedence": 90 + }, + { + "variant_name": "Relu6", + "precedence": 90 + }, + { + "variant_name": "ClampZeroInf", + "precedence": 90 + }, + { + "variant_name": "ClampZeroSix", + "precedence": 90 + }, + { + "variant_name": "FusedConv2D", + "precedence": 60 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "relu_to_clamp", + "premises": [ + { + "target_id": "relu", + "label": "relu: Relu", + "plain_source": "|upright(\"inner\")|", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ |#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]| $]" + }, + { + "target_id": "relu", + "label": "relu: Relu", + "plain_source": "|upright(\"inner\")|", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ |#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]| $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "[upright(\"inner\")]", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ [#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]] $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "relu", + "label": "relu: Relu", + "plain_source": "|upright(\"inner\")|", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ |#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]| $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "[upright(\"inner\")]", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ [#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]] $]" + } + } + ], + "formula_source": { + "plain": "frac(|upright(\"inner\")| \\ |upright(\"inner\")|, |upright(\"inner\")| arrow.r.double [upright(\"inner\")]) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ |#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]| $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ |#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]| $], #text(fill: rgb(\"#5F7A8A\"))[$ |#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]| $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ [#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]] $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_benchmarks_nncase_clamp_microbenchmark_rs__236_5_NncaseClampTx_add_rule__relu6_to_clamp__c12d2395a569e233", + "display_name": "relu6_to_clamp", + "rule_name": "relu6_to_clamp", + "callee": "NncaseClampTx::add_rule", + "file": "src/benchmarks/nncase_clamp_microbenchmark.rs", + "offset": 6624, + "line": 236, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 6624, + "end": 7110 + }, + "pattern_range": { + "start": 6695, + "end": 6973 + }, + "action_range": { + "start": 6983, + "end": 7103 + } + }, + "nodes": [ + { + "id": "inner", + "kind": "query_leaf", + "dsl_type": "ClampExpr", + "label": "inner: ClampExpr", + "range": { + "start": 6712, + "end": 6748 + }, + "inputs": [] + }, + { + "id": "relu", + "kind": "query", + "dsl_type": "Relu6", + "label": "relu: Relu6", + "range": { + "start": 6761, + "end": 6793 + }, + "inputs": [ + "inner" + ] + } + ], + "edges": [ + { + "from": "relu", + "to": "inner", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "inner", + "relu", + "inner", + "relu" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@7018:7054", + "bound_var": "rhs", + "source_text": "ctx.insert_clamp_zero_six(pat.inner)", + "semantic_text": null, + "referenced_pat_vars": [ + "inner" + ], + "referenced_action_vars": [], + "range": { + "start": 7018, + "end": 7054 + } + }, + { + "id": "effect_1", + "effect_id": "effect@7068:7092", + "bound_var": null, + "source_text": "ctx.union(pat.relu, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "relu" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 7068, + "end": 7092 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "Input", + "template": "{name}", + "fields": [ + "name" + ] + } + ], + "typst_templates": [ + { + "variant_name": "Input", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Weight", + "template": "w_({name})", + "fields": [ + "name" + ] + }, + { + "variant_name": "Conv2D", + "template": "({input} * {weight})", + "fields": [ + "input", + "weight" + ] + }, + { + "variant_name": "Relu", + "template": "|{inner}|", + "fields": [ + "inner" + ] + }, + { + "variant_name": "Relu6", + "template": "|{inner}|_6", + "fields": [ + "inner" + ] + }, + { + "variant_name": "ClampZeroInf", + "template": "[{inner}]", + "fields": [ + "inner" + ] + }, + { + "variant_name": "ClampZeroSix", + "template": "[{inner}]_6", + "fields": [ + "inner" + ] + }, + { + "variant_name": "FusedConv2D", + "template": "(({input} * {weight}))_f", + "fields": [ + "input", + "weight" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Input", + "precedence": 100 + }, + { + "variant_name": "Weight", + "precedence": 100 + }, + { + "variant_name": "Conv2D", + "precedence": 60 + }, + { + "variant_name": "Relu", + "precedence": 90 + }, + { + "variant_name": "Relu6", + "precedence": 90 + }, + { + "variant_name": "ClampZeroInf", + "precedence": 90 + }, + { + "variant_name": "ClampZeroSix", + "precedence": 90 + }, + { + "variant_name": "FusedConv2D", + "precedence": 60 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "relu6_to_clamp", + "premises": [ + { + "target_id": "relu", + "label": "relu: Relu6", + "plain_source": "|upright(\"inner\")|upright(\"_6\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ |#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]|upright(\"_6\") $]" + }, + { + "target_id": "relu", + "label": "relu: Relu6", + "plain_source": "|upright(\"inner\")|upright(\"_6\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ |#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]|upright(\"_6\") $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "[upright(\"inner\")]upright(\"_6\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ [#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]]upright(\"_6\") $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "relu", + "label": "relu: Relu6", + "plain_source": "|upright(\"inner\")|upright(\"_6\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ |#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]|upright(\"_6\") $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "[upright(\"inner\")]upright(\"_6\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ [#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]]upright(\"_6\") $]" + } + } + ], + "formula_source": { + "plain": "frac(|upright(\"inner\")|upright(\"_6\") \\ |upright(\"inner\")|upright(\"_6\"), |upright(\"inner\")|upright(\"_6\") arrow.r.double [upright(\"inner\")]upright(\"_6\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ |#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]|upright(\"_6\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ |#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]|upright(\"_6\") $], #text(fill: rgb(\"#5F7A8A\"))[$ |#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]|upright(\"_6\") $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ [#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]]upright(\"_6\") $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_benchmarks_nncase_clamp_microbenchmark_rs__254_5_NncaseClampTx_add_rule__fold_nested_clamp__e029b6458d69aeb6", + "display_name": "fold_nested_clamp", + "rule_name": "fold_nested_clamp", + "callee": "NncaseClampTx::add_rule", + "file": "src/benchmarks/nncase_clamp_microbenchmark.rs", + "offset": 7116, + "line": 254, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 7116, + "end": 7679 + }, + "pattern_range": { + "start": 7190, + "end": 7583 + }, + "action_range": { + "start": 7593, + "end": 7672 + } + }, + "nodes": [ + { + "id": "inner", + "kind": "query_leaf", + "dsl_type": "ClampExpr", + "label": "inner: ClampExpr", + "range": { + "start": 7207, + "end": 7243 + }, + "inputs": [] + }, + { + "id": "inner_clamp", + "kind": "query", + "dsl_type": "ClampZeroInf", + "label": "inner_clamp: ClampZeroInf", + "range": { + "start": 7256, + "end": 7302 + }, + "inputs": [ + "inner" + ] + }, + { + "id": "outer_clamp", + "kind": "query", + "dsl_type": "ClampZeroInf", + "label": "outer_clamp: ClampZeroInf", + "range": { + "start": 7315, + "end": 7367 + }, + "inputs": [ + "inner_clamp" + ] + } + ], + "edges": [ + { + "from": "inner_clamp", + "to": "inner", + "kind": "operand", + "index": 0 + }, + { + "from": "outer_clamp", + "to": "inner_clamp", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "inner_clamp", + "outer_clamp", + "inner_clamp", + "outer_clamp" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@7618:7661", + "bound_var": null, + "source_text": "ctx.union(pat.outer_clamp, pat.inner_clamp)", + "semantic_text": null, + "referenced_pat_vars": [ + "inner_clamp", + "outer_clamp" + ], + "referenced_action_vars": [], + "range": { + "start": 7618, + "end": 7661 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "Input", + "template": "{name}", + "fields": [ + "name" + ] + } + ], + "typst_templates": [ + { + "variant_name": "Input", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Weight", + "template": "w_({name})", + "fields": [ + "name" + ] + }, + { + "variant_name": "Conv2D", + "template": "({input} * {weight})", + "fields": [ + "input", + "weight" + ] + }, + { + "variant_name": "Relu", + "template": "|{inner}|", + "fields": [ + "inner" + ] + }, + { + "variant_name": "Relu6", + "template": "|{inner}|_6", + "fields": [ + "inner" + ] + }, + { + "variant_name": "ClampZeroInf", + "template": "[{inner}]", + "fields": [ + "inner" + ] + }, + { + "variant_name": "ClampZeroSix", + "template": "[{inner}]_6", + "fields": [ + "inner" + ] + }, + { + "variant_name": "FusedConv2D", + "template": "(({input} * {weight}))_f", + "fields": [ + "input", + "weight" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Input", + "precedence": 100 + }, + { + "variant_name": "Weight", + "precedence": 100 + }, + { + "variant_name": "Conv2D", + "precedence": 60 + }, + { + "variant_name": "Relu", + "precedence": 90 + }, + { + "variant_name": "Relu6", + "precedence": 90 + }, + { + "variant_name": "ClampZeroInf", + "precedence": 90 + }, + { + "variant_name": "ClampZeroSix", + "precedence": 90 + }, + { + "variant_name": "FusedConv2D", + "precedence": 60 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "fold_nested_clamp", + "premises": [ + { + "target_id": "inner_clamp", + "label": "inner_clamp: ClampZeroInf", + "plain_source": "[upright(\"inner\")]", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ [#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]] $]" + }, + { + "target_id": "outer_clamp", + "label": "outer_clamp: ClampZeroInf", + "plain_source": "[([upright(\"inner\")])]", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ [(#text(fill: rgb(\"#5F7A8A\"))[$ [#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]] $])] $]" + }, + { + "target_id": "inner_clamp", + "label": "inner_clamp: ClampZeroInf", + "plain_source": "[upright(\"inner\")]", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ [#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]] $]" + }, + { + "target_id": "outer_clamp", + "label": "outer_clamp: ClampZeroInf", + "plain_source": "[([upright(\"inner\")])]", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ [(#text(fill: rgb(\"#5F7A8A\"))[$ [#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]] $])] $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_0", + "from": { + "target_id": "outer_clamp", + "label": "outer_clamp: ClampZeroInf", + "plain_source": "[([upright(\"inner\")])]", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ [(#text(fill: rgb(\"#5F7A8A\"))[$ [#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]] $])] $]" + }, + "to": { + "target_id": "inner_clamp", + "label": "inner_clamp: ClampZeroInf", + "plain_source": "[upright(\"inner\")]", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ [#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]] $]" + } + } + ], + "formula_source": { + "plain": "frac([upright(\"inner\")] \\ [([upright(\"inner\")])] \\ [upright(\"inner\")] \\ [([upright(\"inner\")])], [([upright(\"inner\")])] arrow.r.double [upright(\"inner\")]) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ [#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]] $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ [(#text(fill: rgb(\"#5F7A8A\"))[$ [#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]] $])] $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ [#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]] $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ [(#text(fill: rgb(\"#5F7A8A\"))[$ [#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]] $])] $], #text(fill: rgb(\"#5F7A8A\"))[$ [(#text(fill: rgb(\"#5F7A8A\"))[$ [#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]] $])] $] arrow.r.double #text(fill: rgb(\"#5F7A8A\"))[$ [#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]] $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_benchmarks_nncase_clamp_microbenchmark_rs__272_5_NncaseClampTx_add_rule__fuse_clamp_conv2d__8721f8cc2d093063", + "display_name": "fuse_clamp_conv2d", + "rule_name": "fuse_clamp_conv2d", + "callee": "NncaseClampTx::add_rule", + "file": "src/benchmarks/nncase_clamp_microbenchmark.rs", + "offset": 7685, + "line": 272, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 7685, + "end": 8350 + }, + "pattern_range": { + "start": 7759, + "end": 8201 + }, + "action_range": { + "start": 8211, + "end": 8343 + } + }, + "nodes": [ + { + "id": "input", + "kind": "query_leaf", + "dsl_type": "ClampExpr", + "label": "input: ClampExpr", + "range": { + "start": 7776, + "end": 7812 + }, + "inputs": [] + }, + { + "id": "weight", + "kind": "query_leaf", + "dsl_type": "ClampExpr", + "label": "weight: ClampExpr", + "range": { + "start": 7825, + "end": 7862 + }, + "inputs": [] + }, + { + "id": "conv", + "kind": "query", + "dsl_type": "Conv2D", + "label": "conv: Conv2D", + "range": { + "start": 7875, + "end": 7917 + }, + "inputs": [ + "input", + "weight" + ] + }, + { + "id": "clamp", + "kind": "query", + "dsl_type": "ClampZeroInf", + "label": "clamp: ClampZeroInf", + "range": { + "start": 7930, + "end": 7969 + }, + "inputs": [ + "conv" + ] + } + ], + "edges": [ + { + "from": "conv", + "to": "input", + "kind": "operand", + "index": 0 + }, + { + "from": "conv", + "to": "weight", + "kind": "operand", + "index": 1 + }, + { + "from": "clamp", + "to": "conv", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "input", + "weight", + "clamp", + "input", + "weight", + "clamp" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@8246:8293", + "bound_var": "rhs", + "source_text": "ctx.insert_fused_conv2_d(pat.input, pat.weight)", + "semantic_text": null, + "referenced_pat_vars": [ + "input", + "weight" + ], + "referenced_action_vars": [], + "range": { + "start": 8246, + "end": 8293 + } + }, + { + "id": "effect_1", + "effect_id": "effect@8307:8332", + "bound_var": null, + "source_text": "ctx.union(pat.clamp, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "clamp" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 8307, + "end": 8332 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "Input", + "template": "{name}", + "fields": [ + "name" + ] + } + ], + "typst_templates": [ + { + "variant_name": "Input", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Weight", + "template": "w_({name})", + "fields": [ + "name" + ] + }, + { + "variant_name": "Conv2D", + "template": "({input} * {weight})", + "fields": [ + "input", + "weight" + ] + }, + { + "variant_name": "Relu", + "template": "|{inner}|", + "fields": [ + "inner" + ] + }, + { + "variant_name": "Relu6", + "template": "|{inner}|_6", + "fields": [ + "inner" + ] + }, + { + "variant_name": "ClampZeroInf", + "template": "[{inner}]", + "fields": [ + "inner" + ] + }, + { + "variant_name": "ClampZeroSix", + "template": "[{inner}]_6", + "fields": [ + "inner" + ] + }, + { + "variant_name": "FusedConv2D", + "template": "(({input} * {weight}))_f", + "fields": [ + "input", + "weight" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Input", + "precedence": 100 + }, + { + "variant_name": "Weight", + "precedence": 100 + }, + { + "variant_name": "Conv2D", + "precedence": 60 + }, + { + "variant_name": "Relu", + "precedence": 90 + }, + { + "variant_name": "Relu6", + "precedence": 90 + }, + { + "variant_name": "ClampZeroInf", + "precedence": 90 + }, + { + "variant_name": "ClampZeroSix", + "precedence": 90 + }, + { + "variant_name": "FusedConv2D", + "precedence": 60 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "fuse_clamp_conv2d", + "premises": [ + { + "target_id": "clamp", + "label": "clamp: ClampZeroInf", + "plain_source": "[((upright(\"input\") * upright(\"weight\")))]", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ [(#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"input\") $] * #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"weight\") $]) $])] $]" + }, + { + "target_id": "clamp", + "label": "clamp: ClampZeroInf", + "plain_source": "[((upright(\"input\") * upright(\"weight\")))]", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ [(#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"input\") $] * #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"weight\") $]) $])] $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "((upright(\"input\") * upright(\"weight\")))upright(\"_f\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"input\") $] * #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"weight\") $]))upright(\"_f\") $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "clamp", + "label": "clamp: ClampZeroInf", + "plain_source": "[((upright(\"input\") * upright(\"weight\")))]", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ [(#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"input\") $] * #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"weight\") $]) $])] $]" + }, + "to": { + "target_id": "effect:effect_0", + "label": "rhs", + "plain_source": "((upright(\"input\") * upright(\"weight\")))upright(\"_f\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"input\") $] * #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"weight\") $]))upright(\"_f\") $]" + } + } + ], + "formula_source": { + "plain": "frac([((upright(\"input\") * upright(\"weight\")))] \\ [((upright(\"input\") * upright(\"weight\")))], [((upright(\"input\") * upright(\"weight\")))] arrow.r.double ((upright(\"input\") * upright(\"weight\")))upright(\"_f\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ [(#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"input\") $] * #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"weight\") $]) $])] $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ [(#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"input\") $] * #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"weight\") $]) $])] $], #text(fill: rgb(\"#5F7A8A\"))[$ [(#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"input\") $] * #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"weight\") $]) $])] $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"input\") $] * #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"weight\") $]))upright(\"_f\") $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_benchmarks_nncase_clamp_microbenchmark_rs__297_5_NncaseClampTx_add_rule__seed_name__07c146df267f69a5", + "display_name": "seed_name @ src/benchmarks/nncase_clamp_microbenchmark.rs:297", + "rule_name": "seed_name", + "callee": "NncaseClampTx::add_rule", + "file": "src/benchmarks/nncase_clamp_microbenchmark.rs", + "offset": 8455, + "line": 297, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 8455, + "end": 8997 + }, + "pattern_range": { + "start": 8521, + "end": 8602 + }, + "action_range": { + "start": 8612, + "end": 8990 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Unit" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@8650:8686", + "bound_var": "input", + "source_text": "ctx.insert_input(\"input\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 8650, + "end": 8686 + } + }, + { + "id": "effect_1", + "effect_id": "effect@8713:8747", + "bound_var": "weight", + "source_text": "ctx.insert_weight(\"w0\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 8713, + "end": 8747 + } + }, + { + "id": "effect_2", + "effect_id": "effect@8772:8805", + "bound_var": "conv", + "source_text": "ctx.insert_conv2_d(input, weight)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "input", + "weight" + ], + "range": { + "start": 8772, + "end": 8805 + } + }, + { + "id": "effect_3", + "effect_id": "effect@8819:8840", + "bound_var": null, + "source_text": "ctx.insert_relu(conv)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "conv" + ], + "range": { + "start": 8819, + "end": 8840 + } + }, + { + "id": "effect_4", + "effect_id": "effect@8854:8876", + "bound_var": null, + "source_text": "ctx.insert_relu6(conv)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "conv" + ], + "range": { + "start": 8854, + "end": 8876 + } + }, + { + "id": "effect_5", + "effect_id": "effect@8902:8933", + "bound_var": "clamp", + "source_text": "ctx.insert_clamp_zero_inf(conv)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "conv" + ], + "range": { + "start": 8902, + "end": 8933 + } + }, + { + "id": "effect_6", + "effect_id": "effect@8947:8979", + "bound_var": null, + "source_text": "ctx.insert_clamp_zero_inf(clamp)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "clamp" + ], + "range": { + "start": 8947, + "end": 8979 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "Input", + "template": "{name}", + "fields": [ + "name" + ] + } + ], + "typst_templates": [ + { + "variant_name": "Input", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Weight", + "template": "w_({name})", + "fields": [ + "name" + ] + }, + { + "variant_name": "Conv2D", + "template": "({input} * {weight})", + "fields": [ + "input", + "weight" + ] + }, + { + "variant_name": "Relu", + "template": "|{inner}|", + "fields": [ + "inner" + ] + }, + { + "variant_name": "Relu6", + "template": "|{inner}|_6", + "fields": [ + "inner" + ] + }, + { + "variant_name": "ClampZeroInf", + "template": "[{inner}]", + "fields": [ + "inner" + ] + }, + { + "variant_name": "ClampZeroSix", + "template": "[{inner}]_6", + "fields": [ + "inner" + ] + }, + { + "variant_name": "FusedConv2D", + "template": "(({input} * {weight}))_f", + "fields": [ + "input", + "weight" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Input", + "precedence": 100 + }, + { + "variant_name": "Weight", + "precedence": 100 + }, + { + "variant_name": "Conv2D", + "precedence": 60 + }, + { + "variant_name": "Relu", + "precedence": 90 + }, + { + "variant_name": "Relu6", + "precedence": 90 + }, + { + "variant_name": "ClampZeroInf", + "precedence": 90 + }, + { + "variant_name": "ClampZeroSix", + "precedence": 90 + }, + { + "variant_name": "FusedConv2D", + "precedence": 60 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "rule@8455", + "premises": [ + { + "target_id": "Unit", + "label": "Unit", + "plain_source": "upright(\"Unit\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"Unit\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_benchmarks_nncase_transpose_microbenchmark_rs__221_5_NncaseTransposeTx_add_rule__combine_binary_transpose__3703c82f9496c500", + "display_name": "combine_binary_transpose", + "rule_name": "combine_binary_transpose", + "callee": "NncaseTransposeTx::add_rule", + "file": "src/benchmarks/nncase_transpose_microbenchmark.rs", + "offset": 6154, + "line": 221, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 6154, + "end": 7010 + }, + "pattern_range": { + "start": 6239, + "end": 6805 + }, + "action_range": { + "start": 6815, + "end": 7003 + } + }, + "nodes": [ + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "TransposeExpr", + "label": "lhs: TransposeExpr", + "range": { + "start": 6256, + "end": 6294 + }, + "inputs": [] + }, + { + "id": "rhs", + "kind": "query_leaf", + "dsl_type": "TransposeExpr", + "label": "rhs: TransposeExpr", + "range": { + "start": 6307, + "end": 6345 + }, + "inputs": [] + }, + { + "id": "perm", + "kind": "query_leaf", + "dsl_type": "PermTag", + "label": "perm: PermTag", + "range": { + "start": 6358, + "end": 6391 + }, + "inputs": [] + }, + { + "id": "lhs_t", + "kind": "query", + "dsl_type": "Transpose", + "label": "lhs_t: Transpose", + "range": { + "start": 6404, + "end": 6446 + }, + "inputs": [ + "lhs", + "perm" + ] + }, + { + "id": "rhs_t", + "kind": "query", + "dsl_type": "Transpose", + "label": "rhs_t: Transpose", + "range": { + "start": 6459, + "end": 6501 + }, + "inputs": [ + "rhs", + "perm" + ] + }, + { + "id": "add", + "kind": "query", + "dsl_type": "Add", + "label": "add: Add", + "range": { + "start": 6514, + "end": 6551 + }, + "inputs": [ + "lhs_t", + "rhs_t" + ] + } + ], + "edges": [ + { + "from": "lhs_t", + "to": "lhs", + "kind": "operand", + "index": 0 + }, + { + "from": "lhs_t", + "to": "perm", + "kind": "operand", + "index": 1 + }, + { + "from": "rhs_t", + "to": "rhs", + "kind": "operand", + "index": 0 + }, + { + "from": "rhs_t", + "to": "perm", + "kind": "operand", + "index": 1 + }, + { + "from": "add", + "to": "lhs_t", + "kind": "operand", + "index": 0 + }, + { + "from": "add", + "to": "rhs_t", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "lhs", + "rhs", + "perm", + "add", + "lhs", + "rhs", + "perm", + "add" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@6857:6889", + "bound_var": "pushed_add", + "source_text": "ctx.insert_add(pat.lhs, pat.rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "lhs", + "rhs" + ], + "referenced_action_vars": [], + "range": { + "start": 6857, + "end": 6889 + } + }, + { + "id": "effect_1", + "effect_id": "effect@6913:6955", + "bound_var": "rhs", + "source_text": "ctx.insert_transpose(pushed_add, pat.perm)", + "semantic_text": null, + "referenced_pat_vars": [ + "perm" + ], + "referenced_action_vars": [ + "pushed_add" + ], + "range": { + "start": 6913, + "end": 6955 + } + }, + { + "id": "effect_2", + "effect_id": "effect@6969:6992", + "bound_var": null, + "source_text": "ctx.union(pat.add, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "add" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 6969, + "end": 6992 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "TransposeInput", + "template": "{name}", + "fields": [ + "name" + ] + } + ], + "typst_templates": [ + { + "variant_name": "PermId", + "template": "id", + "fields": [] + }, + { + "variant_name": "PermSwap", + "template": "sigma", + "fields": [] + }, + { + "variant_name": "TransposeInput", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Transpose", + "template": "T_{perm}({inner})", + "fields": [ + "inner", + "perm" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "UnaryExp", + "template": "exp({inner})", + "fields": [ + "inner" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "PermId", + "precedence": 100 + }, + { + "variant_name": "PermSwap", + "precedence": 100 + }, + { + "variant_name": "TransposeInput", + "precedence": 100 + }, + { + "variant_name": "Transpose", + "precedence": 80 + }, + { + "variant_name": "Add", + "precedence": 40 + }, + { + "variant_name": "UnaryExp", + "precedence": 90 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "combine_binary_transpose", + "premises": [ + { + "target_id": "add", + "label": "add: Add", + "plain_source": "upright(\"T_\")upright(\"perm\")(upright(\"lhs\")) + upright(\"T_\")upright(\"perm\")(upright(\"rhs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"perm\") $](#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) $] + #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"perm\") $](#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $]) $] $]" + }, + { + "target_id": "add", + "label": "add: Add", + "plain_source": "upright(\"T_\")upright(\"perm\")(upright(\"lhs\")) + upright(\"T_\")upright(\"perm\")(upright(\"rhs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"perm\") $](#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) $] + #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"perm\") $](#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $]) $] $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "pushed_add", + "plain_source": "upright(\"pushed_add\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"pushed_add\") $]" + }, + { + "target_id": "effect:effect_1", + "label": "rhs", + "plain_source": "upright(\"rhs\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"rhs\") $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "add", + "label": "add: Add", + "plain_source": "upright(\"T_\")upright(\"perm\")(upright(\"lhs\")) + upright(\"T_\")upright(\"perm\")(upright(\"rhs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"perm\") $](#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) $] + #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"perm\") $](#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $]) $] $]" + }, + "to": { + "target_id": "effect:effect_1", + "label": "rhs", + "plain_source": "upright(\"rhs\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"rhs\") $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"T_\")upright(\"perm\")(upright(\"lhs\")) + upright(\"T_\")upright(\"perm\")(upright(\"rhs\")) \\ upright(\"T_\")upright(\"perm\")(upright(\"lhs\")) + upright(\"T_\")upright(\"perm\")(upright(\"rhs\")), upright(\"T_\")upright(\"perm\")(upright(\"lhs\")) + upright(\"T_\")upright(\"perm\")(upright(\"rhs\")) arrow.r.double upright(\"rhs\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"perm\") $](#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) $] + #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"perm\") $](#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $]) $] $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"perm\") $](#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) $] + #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"perm\") $](#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $]) $] $], #text(fill: rgb(\"#5F7A8A\"))[$ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"perm\") $](#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]) $] + #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"perm\") $](#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $]) $] $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"rhs\") $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_benchmarks_nncase_transpose_microbenchmark_rs__247_5_NncaseTransposeTx_add_rule__combine_unary_transpose__e6b0b4259ac2a878", + "display_name": "combine_unary_transpose", + "rule_name": "combine_unary_transpose", + "callee": "NncaseTransposeTx::add_rule", + "file": "src/benchmarks/nncase_transpose_microbenchmark.rs", + "offset": 7017, + "line": 247, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 7017, + "end": 7724 + }, + "pattern_range": { + "start": 7101, + "end": 7522 + }, + "action_range": { + "start": 7532, + "end": 7717 + } + }, + "nodes": [ + { + "id": "inner", + "kind": "query_leaf", + "dsl_type": "TransposeExpr", + "label": "inner: TransposeExpr", + "range": { + "start": 7118, + "end": 7158 + }, + "inputs": [] + }, + { + "id": "perm", + "kind": "query_leaf", + "dsl_type": "PermTag", + "label": "perm: PermTag", + "range": { + "start": 7171, + "end": 7204 + }, + "inputs": [] + }, + { + "id": "t", + "kind": "query", + "dsl_type": "Transpose", + "label": "t: Transpose", + "range": { + "start": 7217, + "end": 7257 + }, + "inputs": [ + "inner", + "perm" + ] + }, + { + "id": "exp", + "kind": "query", + "dsl_type": "UnaryExp", + "label": "exp: UnaryExp", + "range": { + "start": 7270, + "end": 7300 + }, + "inputs": [ + "t" + ] + } + ], + "edges": [ + { + "from": "t", + "to": "inner", + "kind": "operand", + "index": 0 + }, + { + "from": "t", + "to": "perm", + "kind": "operand", + "index": 1 + }, + { + "from": "exp", + "to": "t", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "inner", + "perm", + "exp", + "inner", + "perm", + "exp" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@7573:7604", + "bound_var": "inner_exp", + "source_text": "ctx.insert_unary_exp(pat.inner)", + "semantic_text": null, + "referenced_pat_vars": [ + "inner" + ], + "referenced_action_vars": [], + "range": { + "start": 7573, + "end": 7604 + } + }, + { + "id": "effect_1", + "effect_id": "effect@7628:7669", + "bound_var": "rhs", + "source_text": "ctx.insert_transpose(inner_exp, pat.perm)", + "semantic_text": null, + "referenced_pat_vars": [ + "perm" + ], + "referenced_action_vars": [ + "inner_exp" + ], + "range": { + "start": 7628, + "end": 7669 + } + }, + { + "id": "effect_2", + "effect_id": "effect@7683:7706", + "bound_var": null, + "source_text": "ctx.union(pat.exp, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "exp" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 7683, + "end": 7706 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "TransposeInput", + "template": "{name}", + "fields": [ + "name" + ] + } + ], + "typst_templates": [ + { + "variant_name": "PermId", + "template": "id", + "fields": [] + }, + { + "variant_name": "PermSwap", + "template": "sigma", + "fields": [] + }, + { + "variant_name": "TransposeInput", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Transpose", + "template": "T_{perm}({inner})", + "fields": [ + "inner", + "perm" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "UnaryExp", + "template": "exp({inner})", + "fields": [ + "inner" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "PermId", + "precedence": 100 + }, + { + "variant_name": "PermSwap", + "precedence": 100 + }, + { + "variant_name": "TransposeInput", + "precedence": 100 + }, + { + "variant_name": "Transpose", + "precedence": 80 + }, + { + "variant_name": "Add", + "precedence": 40 + }, + { + "variant_name": "UnaryExp", + "precedence": 90 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "combine_unary_transpose", + "premises": [ + { + "target_id": "exp", + "label": "exp: UnaryExp", + "plain_source": "upright(\"exp\")((upright(\"T_\")upright(\"perm\")(upright(\"inner\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"exp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"perm\") $](#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]) $])) $]" + }, + { + "target_id": "exp", + "label": "exp: UnaryExp", + "plain_source": "upright(\"exp\")((upright(\"T_\")upright(\"perm\")(upright(\"inner\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"exp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"perm\") $](#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]) $])) $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "inner_exp", + "plain_source": "upright(\"exp\")(upright(\"inner\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"exp\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "rhs", + "plain_source": "upright(\"T_\")upright(\"perm\")(upright(\"exp\")(upright(\"inner\")))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"perm\") $](#text(fill: rgb(\"#B86A5B\"))[$ upright(\"exp\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]) $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "exp", + "label": "exp: UnaryExp", + "plain_source": "upright(\"exp\")((upright(\"T_\")upright(\"perm\")(upright(\"inner\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"exp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"perm\") $](#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]) $])) $]" + }, + "to": { + "target_id": "effect:effect_1", + "label": "rhs", + "plain_source": "upright(\"T_\")upright(\"perm\")(upright(\"exp\")(upright(\"inner\")))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"perm\") $](#text(fill: rgb(\"#B86A5B\"))[$ upright(\"exp\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]) $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"exp\")((upright(\"T_\")upright(\"perm\")(upright(\"inner\")))) \\ upright(\"exp\")((upright(\"T_\")upright(\"perm\")(upright(\"inner\")))), upright(\"exp\")((upright(\"T_\")upright(\"perm\")(upright(\"inner\")))) arrow.r.double upright(\"T_\")upright(\"perm\")(upright(\"exp\")(upright(\"inner\")))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"exp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"perm\") $](#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"exp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"perm\") $](#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]) $])) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"exp\")((#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"perm\") $](#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]) $])) $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"perm\") $](#text(fill: rgb(\"#B86A5B\"))[$ upright(\"exp\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]) $]) $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_benchmarks_nncase_transpose_microbenchmark_rs__270_5_NncaseTransposeTx_add_rule__fold_two_transposes__17f3d2a5816da6d4", + "display_name": "fold_two_transposes", + "rule_name": "fold_two_transposes", + "callee": "NncaseTransposeTx::add_rule", + "file": "src/benchmarks/nncase_transpose_microbenchmark.rs", + "offset": 7731, + "line": 270, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 7731, + "end": 8280 + }, + "pattern_range": { + "start": 7811, + "end": 8199 + }, + "action_range": { + "start": 8209, + "end": 8273 + } + }, + "nodes": [ + { + "id": "inner", + "kind": "query_leaf", + "dsl_type": "TransposeExpr", + "label": "inner: TransposeExpr", + "range": { + "start": 7828, + "end": 7868 + }, + "inputs": [] + }, + { + "id": "perm", + "kind": "query", + "dsl_type": "PermSwap", + "label": "perm: PermSwap", + "range": { + "start": 7881, + "end": 7910 + }, + "inputs": [] + }, + { + "id": "t1", + "kind": "query", + "dsl_type": "Transpose", + "label": "t1: Transpose", + "range": { + "start": 7923, + "end": 7964 + }, + "inputs": [ + "inner", + "perm" + ] + }, + { + "id": "t2", + "kind": "query", + "dsl_type": "Transpose", + "label": "t2: Transpose", + "range": { + "start": 7977, + "end": 8015 + }, + "inputs": [ + "t1", + "perm" + ] + } + ], + "edges": [ + { + "from": "t1", + "to": "inner", + "kind": "operand", + "index": 0 + }, + { + "from": "t1", + "to": "perm", + "kind": "operand", + "index": 1 + }, + { + "from": "t2", + "to": "t1", + "kind": "operand", + "index": 0 + }, + { + "from": "t2", + "to": "perm", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "inner", + "t2", + "inner", + "t2" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@8234:8262", + "bound_var": null, + "source_text": "ctx.union(pat.t2, pat.inner)", + "semantic_text": null, + "referenced_pat_vars": [ + "inner", + "t2" + ], + "referenced_action_vars": [], + "range": { + "start": 8234, + "end": 8262 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "TransposeInput", + "template": "{name}", + "fields": [ + "name" + ] + } + ], + "typst_templates": [ + { + "variant_name": "PermId", + "template": "id", + "fields": [] + }, + { + "variant_name": "PermSwap", + "template": "sigma", + "fields": [] + }, + { + "variant_name": "TransposeInput", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Transpose", + "template": "T_{perm}({inner})", + "fields": [ + "inner", + "perm" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "UnaryExp", + "template": "exp({inner})", + "fields": [ + "inner" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "PermId", + "precedence": 100 + }, + { + "variant_name": "PermSwap", + "precedence": 100 + }, + { + "variant_name": "TransposeInput", + "precedence": 100 + }, + { + "variant_name": "Transpose", + "precedence": 80 + }, + { + "variant_name": "Add", + "precedence": 40 + }, + { + "variant_name": "UnaryExp", + "precedence": 90 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "fold_two_transposes", + "premises": [ + { + "target_id": "t2", + "label": "t2: Transpose", + "plain_source": "upright(\"T_\")upright(\"perm\")(t_1)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"perm\") $](#text(fill: rgb(\"#5F7A8A\"))[$ t_1 $]) $]" + }, + { + "target_id": "t2", + "label": "t2: Transpose", + "plain_source": "upright(\"T_\")upright(\"perm\")(t_1)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"perm\") $](#text(fill: rgb(\"#5F7A8A\"))[$ t_1 $]) $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_0", + "from": { + "target_id": "t2", + "label": "t2: Transpose", + "plain_source": "upright(\"T_\")upright(\"perm\")(t_1)", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"perm\") $](#text(fill: rgb(\"#5F7A8A\"))[$ t_1 $]) $]" + }, + "to": { + "target_id": "inner", + "label": "inner: TransposeExpr", + "plain_source": "upright(\"inner\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"T_\")upright(\"perm\")(t_1) \\ upright(\"T_\")upright(\"perm\")(t_1), upright(\"T_\")upright(\"perm\")(t_1) arrow.r.double upright(\"inner\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"perm\") $](#text(fill: rgb(\"#5F7A8A\"))[$ t_1 $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"perm\") $](#text(fill: rgb(\"#5F7A8A\"))[$ t_1 $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"perm\") $](#text(fill: rgb(\"#5F7A8A\"))[$ t_1 $]) $] arrow.r.double #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_benchmarks_nncase_transpose_microbenchmark_rs__290_5_NncaseTransposeTx_add_rule__fold_nop_transpose__e14afe450f5220de", + "display_name": "fold_nop_transpose", + "rule_name": "fold_nop_transpose", + "callee": "NncaseTransposeTx::add_rule", + "file": "src/benchmarks/nncase_transpose_microbenchmark.rs", + "offset": 8287, + "line": 290, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 8287, + "end": 8778 + }, + "pattern_range": { + "start": 8366, + "end": 8698 + }, + "action_range": { + "start": 8708, + "end": 8771 + } + }, + "nodes": [ + { + "id": "inner", + "kind": "query_leaf", + "dsl_type": "TransposeExpr", + "label": "inner: TransposeExpr", + "range": { + "start": 8383, + "end": 8423 + }, + "inputs": [] + }, + { + "id": "perm", + "kind": "query", + "dsl_type": "PermId", + "label": "perm: PermId", + "range": { + "start": 8436, + "end": 8463 + }, + "inputs": [] + }, + { + "id": "t", + "kind": "query", + "dsl_type": "Transpose", + "label": "t: Transpose", + "range": { + "start": 8476, + "end": 8516 + }, + "inputs": [ + "inner", + "perm" + ] + } + ], + "edges": [ + { + "from": "t", + "to": "inner", + "kind": "operand", + "index": 0 + }, + { + "from": "t", + "to": "perm", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "inner", + "t", + "inner", + "t" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@8733:8760", + "bound_var": null, + "source_text": "ctx.union(pat.t, pat.inner)", + "semantic_text": null, + "referenced_pat_vars": [ + "inner", + "t" + ], + "referenced_action_vars": [], + "range": { + "start": 8733, + "end": 8760 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "TransposeInput", + "template": "{name}", + "fields": [ + "name" + ] + } + ], + "typst_templates": [ + { + "variant_name": "PermId", + "template": "id", + "fields": [] + }, + { + "variant_name": "PermSwap", + "template": "sigma", + "fields": [] + }, + { + "variant_name": "TransposeInput", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Transpose", + "template": "T_{perm}({inner})", + "fields": [ + "inner", + "perm" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "UnaryExp", + "template": "exp({inner})", + "fields": [ + "inner" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "PermId", + "precedence": 100 + }, + { + "variant_name": "PermSwap", + "precedence": 100 + }, + { + "variant_name": "TransposeInput", + "precedence": 100 + }, + { + "variant_name": "Transpose", + "precedence": 80 + }, + { + "variant_name": "Add", + "precedence": 40 + }, + { + "variant_name": "UnaryExp", + "precedence": 90 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "fold_nop_transpose", + "premises": [ + { + "target_id": "t", + "label": "t: Transpose", + "plain_source": "upright(\"T_\")upright(\"id\")(upright(\"inner\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"id\") $](#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]) $]" + }, + { + "target_id": "t", + "label": "t: Transpose", + "plain_source": "upright(\"T_\")upright(\"id\")(upright(\"inner\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"id\") $](#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]) $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_0", + "from": { + "target_id": "t", + "label": "t: Transpose", + "plain_source": "upright(\"T_\")upright(\"id\")(upright(\"inner\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"id\") $](#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]) $]" + }, + "to": { + "target_id": "inner", + "label": "inner: TransposeExpr", + "plain_source": "upright(\"inner\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"T_\")upright(\"id\")(upright(\"inner\")) \\ upright(\"T_\")upright(\"id\")(upright(\"inner\")), upright(\"T_\")upright(\"id\")(upright(\"inner\")) arrow.r.double upright(\"inner\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"id\") $](#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"id\") $](#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"T_\")#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"id\") $](#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]) $] arrow.r.double #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_benchmarks_nncase_transpose_microbenchmark_rs__312_5_NncaseTransposeTx_add_rule__seed_name__4fbf64d786d5d359", + "display_name": "seed_name @ src/benchmarks/nncase_transpose_microbenchmark.rs:312", + "rule_name": "seed_name", + "callee": "NncaseTransposeTx::add_rule", + "file": "src/benchmarks/nncase_transpose_microbenchmark.rs", + "offset": 8887, + "line": 312, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 8887, + "end": 9894 + }, + "pattern_range": { + "start": 8957, + "end": 9038 + }, + "action_range": { + "start": 9048, + "end": 9887 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Unit" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@9084:9128", + "bound_var": "lhs", + "source_text": "ctx.insert_transpose_input(\"lhs\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 9084, + "end": 9128 + } + }, + { + "id": "effect_1", + "effect_id": "effect@9152:9196", + "bound_var": "rhs", + "source_text": "ctx.insert_transpose_input(\"rhs\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 9152, + "end": 9196 + } + }, + { + "id": "effect_2", + "effect_id": "effect@9220:9264", + "bound_var": "aux", + "source_text": "ctx.insert_transpose_input(\"aux\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 9220, + "end": 9264 + } + }, + { + "id": "effect_3", + "effect_id": "effect@9289:9311", + "bound_var": "swap", + "source_text": "ctx.insert_perm_swap()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 9289, + "end": 9311 + } + }, + { + "id": "effect_4", + "effect_id": "effect@9334:9354", + "bound_var": "id", + "source_text": "ctx.insert_perm_id()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 9334, + "end": 9354 + } + }, + { + "id": "effect_5", + "effect_id": "effect@9381:9412", + "bound_var": "lhs_t", + "source_text": "ctx.insert_transpose(lhs, swap)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "lhs", + "swap" + ], + "range": { + "start": 9381, + "end": 9412 + } + }, + { + "id": "effect_6", + "effect_id": "effect@9440:9465", + "bound_var": "rhs_exp", + "source_text": "ctx.insert_unary_exp(rhs)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 9440, + "end": 9465 + } + }, + { + "id": "effect_7", + "effect_id": "effect@9491:9526", + "bound_var": "rhs_t", + "source_text": "ctx.insert_transpose(rhs_exp, swap)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "rhs_exp", + "swap" + ], + "range": { + "start": 9491, + "end": 9526 + } + }, + { + "id": "effect_8", + "effect_id": "effect@9550:9578", + "bound_var": "add", + "source_text": "ctx.insert_add(lhs_t, rhs_t)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "lhs_t", + "rhs_t" + ], + "range": { + "start": 9550, + "end": 9578 + } + }, + { + "id": "effect_9", + "effect_id": "effect@9592:9623", + "bound_var": null, + "source_text": "ctx.insert_transpose(add, swap)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "add", + "swap" + ], + "range": { + "start": 9592, + "end": 9623 + } + }, + { + "id": "effect_10", + "effect_id": "effect@9651:9680", + "bound_var": "aux_id", + "source_text": "ctx.insert_transpose(aux, id)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "aux", + "id" + ], + "range": { + "start": 9651, + "end": 9680 + } + }, + { + "id": "effect_11", + "effect_id": "effect@9694:9722", + "bound_var": null, + "source_text": "ctx.insert_unary_exp(aux_id)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "aux_id" + ], + "range": { + "start": 9694, + "end": 9722 + } + }, + { + "id": "effect_12", + "effect_id": "effect@9751:9782", + "bound_var": "aux_swap", + "source_text": "ctx.insert_transpose(aux, swap)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "aux", + "swap" + ], + "range": { + "start": 9751, + "end": 9782 + } + }, + { + "id": "effect_13", + "effect_id": "effect@9796:9826", + "bound_var": null, + "source_text": "ctx.insert_unary_exp(aux_swap)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "aux_swap" + ], + "range": { + "start": 9796, + "end": 9826 + } + }, + { + "id": "effect_14", + "effect_id": "effect@9840:9876", + "bound_var": null, + "source_text": "ctx.insert_transpose(aux_swap, swap)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "aux_swap", + "swap" + ], + "range": { + "start": 9840, + "end": 9876 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "TransposeInput", + "template": "{name}", + "fields": [ + "name" + ] + } + ], + "typst_templates": [ + { + "variant_name": "PermId", + "template": "id", + "fields": [] + }, + { + "variant_name": "PermSwap", + "template": "sigma", + "fields": [] + }, + { + "variant_name": "TransposeInput", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Transpose", + "template": "T_{perm}({inner})", + "fields": [ + "inner", + "perm" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "UnaryExp", + "template": "exp({inner})", + "fields": [ + "inner" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "PermId", + "precedence": 100 + }, + { + "variant_name": "PermSwap", + "precedence": 100 + }, + { + "variant_name": "TransposeInput", + "precedence": 100 + }, + { + "variant_name": "Transpose", + "precedence": 80 + }, + { + "variant_name": "Add", + "precedence": 40 + }, + { + "variant_name": "UnaryExp", + "precedence": 90 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "rule@8887", + "premises": [ + { + "target_id": "Unit", + "label": "Unit", + "plain_source": "upright(\"Unit\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"Unit\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_benchmarks_nncase_vectorize_microbenchmark_rs__240_5_NncaseVectorizeTx_add_rule__meta_pack_matmul__b785399a37450988", + "display_name": "meta_pack_matmul", + "rule_name": "meta_pack_matmul", + "callee": "NncaseVectorizeTx::add_rule", + "file": "src/benchmarks/nncase_vectorize_microbenchmark.rs", + "offset": 6546, + "line": 240, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 6546, + "end": 7395 + }, + "pattern_range": { + "start": 6623, + "end": 7009 + }, + "action_range": { + "start": 7019, + "end": 7388 + } + }, + "nodes": [ + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "VectorizeExpr", + "label": "lhs: VectorizeExpr", + "range": { + "start": 6640, + "end": 6678 + }, + "inputs": [] + }, + { + "id": "rhs", + "kind": "query_leaf", + "dsl_type": "VectorizeExpr", + "label": "rhs: VectorizeExpr", + "range": { + "start": 6691, + "end": 6729 + }, + "inputs": [] + }, + { + "id": "mm", + "kind": "query", + "dsl_type": "LogicalMatMul", + "label": "mm: LogicalMatMul", + "range": { + "start": 6742, + "end": 6784 + }, + "inputs": [ + "lhs", + "rhs" + ] + } + ], + "edges": [ + { + "from": "mm", + "to": "lhs", + "kind": "operand", + "index": 0 + }, + { + "from": "mm", + "to": "rhs", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "lhs", + "rhs", + "mm", + "lhs", + "rhs", + "mm" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@7058:7078", + "bound_var": "blocked", + "source_text": "ctx.insert_blocked()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 7058, + "end": 7078 + } + }, + { + "id": "effect_1", + "effect_id": "effect@7107:7140", + "bound_var": "lhs_pack", + "source_text": "ctx.insert_pack(pat.lhs, blocked)", + "semantic_text": null, + "referenced_pat_vars": [ + "lhs" + ], + "referenced_action_vars": [ + "blocked" + ], + "range": { + "start": 7107, + "end": 7140 + } + }, + { + "id": "effect_2", + "effect_id": "effect@7169:7202", + "bound_var": "rhs_pack", + "source_text": "ctx.insert_pack(pat.rhs, blocked)", + "semantic_text": null, + "referenced_pat_vars": [ + "rhs" + ], + "referenced_action_vars": [ + "blocked" + ], + "range": { + "start": 7169, + "end": 7202 + } + }, + { + "id": "effect_3", + "effect_id": "effect@7229:7283", + "bound_var": "packed", + "source_text": "ctx.insert_packed_mat_mul(lhs_pack, rhs_pack, blocked)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "blocked", + "lhs_pack", + "rhs_pack" + ], + "range": { + "start": 7229, + "end": 7283 + } + }, + { + "id": "effect_4", + "effect_id": "effect@7307:7341", + "bound_var": "rhs", + "source_text": "ctx.insert_unpack(packed, blocked)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "blocked", + "packed" + ], + "range": { + "start": 7307, + "end": 7341 + } + }, + { + "id": "effect_5", + "effect_id": "effect@7355:7377", + "bound_var": null, + "source_text": "ctx.union(pat.mm, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "mm" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 7355, + "end": 7377 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "VectorizeInput", + "template": "{name}", + "fields": [ + "name" + ] + } + ], + "typst_templates": [ + { + "variant_name": "Flat", + "template": "f", + "fields": [] + }, + { + "variant_name": "Blocked", + "template": "b", + "fields": [] + }, + { + "variant_name": "VectorizeInput", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "LogicalMatMul", + "template": "({lhs} * {rhs})", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "LogicalExp", + "template": "e^({inner})", + "fields": [ + "inner" + ] + }, + { + "variant_name": "Pack", + "template": "({inner})_({layout})", + "fields": [ + "inner", + "layout" + ] + }, + { + "variant_name": "Unpack", + "template": "({inner})^({layout})", + "fields": [ + "inner", + "layout" + ] + }, + { + "variant_name": "PackedMatMul", + "template": "(({lhs} * {rhs}))_({layout})", + "fields": [ + "lhs", + "rhs", + "layout" + ] + }, + { + "variant_name": "PackedExp", + "template": "(e^({inner}))_({layout})", + "fields": [ + "inner", + "layout" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Flat", + "precedence": 100 + }, + { + "variant_name": "Blocked", + "precedence": 100 + }, + { + "variant_name": "VectorizeInput", + "precedence": 100 + }, + { + "variant_name": "LogicalMatMul", + "precedence": 50 + }, + { + "variant_name": "LogicalExp", + "precedence": 90 + }, + { + "variant_name": "Pack", + "precedence": 90 + }, + { + "variant_name": "Unpack", + "precedence": 90 + }, + { + "variant_name": "PackedMatMul", + "precedence": 50 + }, + { + "variant_name": "PackedExp", + "precedence": 90 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "meta_pack_matmul", + "premises": [ + { + "target_id": "mm", + "label": "mm: LogicalMatMul", + "plain_source": "(upright(\"lhs\") * upright(\"rhs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] * #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $]) $]" + }, + { + "target_id": "mm", + "label": "mm: LogicalMatMul", + "plain_source": "(upright(\"lhs\") * upright(\"rhs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] * #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $]) $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "blocked", + "plain_source": "b", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ b $]" + }, + { + "target_id": "effect:effect_1", + "label": "lhs_pack", + "plain_source": "(upright(\"lhs\"))upright(\"_\")(b)", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $])upright(\"_\")(#text(fill: rgb(\"#B86A5B\"))[$ b $]) $]" + }, + { + "target_id": "effect:effect_2", + "label": "rhs_pack", + "plain_source": "upright(\"rhs_pack\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"rhs_pack\") $]" + }, + { + "target_id": "effect:effect_3", + "label": "packed", + "plain_source": "upright(\"packed\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"packed\") $]" + }, + { + "target_id": "effect:effect_4", + "label": "rhs", + "plain_source": "upright(\"rhs\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"rhs\") $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_5", + "from": { + "target_id": "mm", + "label": "mm: LogicalMatMul", + "plain_source": "(upright(\"lhs\") * upright(\"rhs\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] * #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $]) $]" + }, + "to": { + "target_id": "effect:effect_4", + "label": "rhs", + "plain_source": "upright(\"rhs\")", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ upright(\"rhs\") $]" + } + } + ], + "formula_source": { + "plain": "frac((upright(\"lhs\") * upright(\"rhs\")) \\ (upright(\"lhs\") * upright(\"rhs\")), (upright(\"lhs\") * upright(\"rhs\")) arrow.r.double upright(\"rhs\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] * #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] * #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] * #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $]) $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ upright(\"rhs\") $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_benchmarks_nncase_vectorize_microbenchmark_rs__265_5_NncaseVectorizeTx_add_rule__meta_pack_exp__f712635bf560f36a", + "display_name": "meta_pack_exp", + "rule_name": "meta_pack_exp", + "callee": "NncaseVectorizeTx::add_rule", + "file": "src/benchmarks/nncase_vectorize_microbenchmark.rs", + "offset": 7402, + "line": 265, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 7402, + "end": 8128 + }, + "pattern_range": { + "start": 7476, + "end": 7920 + }, + "action_range": { + "start": 7930, + "end": 8121 + } + }, + "nodes": [ + { + "id": "inner", + "kind": "query_leaf", + "dsl_type": "VectorizeExpr", + "label": "inner: VectorizeExpr", + "range": { + "start": 7493, + "end": 7533 + }, + "inputs": [] + }, + { + "id": "layout", + "kind": "query_leaf", + "dsl_type": "LayoutTag", + "label": "layout: LayoutTag", + "range": { + "start": 7546, + "end": 7583 + }, + "inputs": [] + }, + { + "id": "unpack", + "kind": "query", + "dsl_type": "Unpack", + "label": "unpack: Unpack", + "range": { + "start": 7596, + "end": 7640 + }, + "inputs": [ + "inner", + "layout" + ] + }, + { + "id": "exp", + "kind": "query", + "dsl_type": "LogicalExp", + "label": "exp: LogicalExp", + "range": { + "start": 7653, + "end": 7690 + }, + "inputs": [ + "unpack" + ] + } + ], + "edges": [ + { + "from": "unpack", + "to": "inner", + "kind": "operand", + "index": 0 + }, + { + "from": "unpack", + "to": "layout", + "kind": "operand", + "index": 1 + }, + { + "from": "exp", + "to": "unpack", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "inner", + "layout", + "exp", + "inner", + "layout", + "exp" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@7968:8012", + "bound_var": "packed", + "source_text": "ctx.insert_packed_exp(pat.inner, pat.layout)", + "semantic_text": null, + "referenced_pat_vars": [ + "inner", + "layout" + ], + "referenced_action_vars": [], + "range": { + "start": 7968, + "end": 8012 + } + }, + { + "id": "effect_1", + "effect_id": "effect@8036:8073", + "bound_var": "rhs", + "source_text": "ctx.insert_unpack(packed, pat.layout)", + "semantic_text": null, + "referenced_pat_vars": [ + "layout" + ], + "referenced_action_vars": [ + "packed" + ], + "range": { + "start": 8036, + "end": 8073 + } + }, + { + "id": "effect_2", + "effect_id": "effect@8087:8110", + "bound_var": null, + "source_text": "ctx.union(pat.exp, rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "exp" + ], + "referenced_action_vars": [ + "rhs" + ], + "range": { + "start": 8087, + "end": 8110 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "VectorizeInput", + "template": "{name}", + "fields": [ + "name" + ] + } + ], + "typst_templates": [ + { + "variant_name": "Flat", + "template": "f", + "fields": [] + }, + { + "variant_name": "Blocked", + "template": "b", + "fields": [] + }, + { + "variant_name": "VectorizeInput", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "LogicalMatMul", + "template": "({lhs} * {rhs})", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "LogicalExp", + "template": "e^({inner})", + "fields": [ + "inner" + ] + }, + { + "variant_name": "Pack", + "template": "({inner})_({layout})", + "fields": [ + "inner", + "layout" + ] + }, + { + "variant_name": "Unpack", + "template": "({inner})^({layout})", + "fields": [ + "inner", + "layout" + ] + }, + { + "variant_name": "PackedMatMul", + "template": "(({lhs} * {rhs}))_({layout})", + "fields": [ + "lhs", + "rhs", + "layout" + ] + }, + { + "variant_name": "PackedExp", + "template": "(e^({inner}))_({layout})", + "fields": [ + "inner", + "layout" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Flat", + "precedence": 100 + }, + { + "variant_name": "Blocked", + "precedence": 100 + }, + { + "variant_name": "VectorizeInput", + "precedence": 100 + }, + { + "variant_name": "LogicalMatMul", + "precedence": 50 + }, + { + "variant_name": "LogicalExp", + "precedence": 90 + }, + { + "variant_name": "Pack", + "precedence": 90 + }, + { + "variant_name": "Unpack", + "precedence": 90 + }, + { + "variant_name": "PackedMatMul", + "precedence": 50 + }, + { + "variant_name": "PackedExp", + "precedence": 90 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "meta_pack_exp", + "premises": [ + { + "target_id": "exp", + "label": "exp: LogicalExp", + "plain_source": "e^(((upright(\"inner\"))^(upright(\"layout\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ e^((#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $])^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $])) $]" + }, + { + "target_id": "exp", + "label": "exp: LogicalExp", + "plain_source": "e^(((upright(\"inner\"))^(upright(\"layout\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ e^((#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $])^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $])) $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "packed", + "plain_source": "(e^(upright(\"inner\")))upright(\"_\")(upright(\"layout\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ (e^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]))upright(\"_\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $]" + }, + { + "target_id": "effect:effect_1", + "label": "rhs", + "plain_source": "(((e^(upright(\"inner\")))upright(\"_\")(upright(\"layout\"))))^(upright(\"layout\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (e^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]))upright(\"_\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $]))^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $]" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "exp", + "label": "exp: LogicalExp", + "plain_source": "e^(((upright(\"inner\"))^(upright(\"layout\"))))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ e^((#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $])^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $])) $]" + }, + "to": { + "target_id": "effect:effect_1", + "label": "rhs", + "plain_source": "(((e^(upright(\"inner\")))upright(\"_\")(upright(\"layout\"))))^(upright(\"layout\"))", + "colored_source": "#text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (e^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]))upright(\"_\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $]))^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $]" + } + } + ], + "formula_source": { + "plain": "frac(e^(((upright(\"inner\"))^(upright(\"layout\")))) \\ e^(((upright(\"inner\"))^(upright(\"layout\")))), e^(((upright(\"inner\"))^(upright(\"layout\")))) arrow.r.double (((e^(upright(\"inner\")))upright(\"_\")(upright(\"layout\"))))^(upright(\"layout\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ e^((#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $])^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $])) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ e^((#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $])^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $])) $], #text(fill: rgb(\"#5F7A8A\"))[$ e^((#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $])^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $])) $] arrow.r.double #text(fill: rgb(\"#B86A5B\"))[$ ((#text(fill: rgb(\"#B86A5B\"))[$ (e^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]))upright(\"_\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $]))^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_benchmarks_nncase_vectorize_microbenchmark_rs__288_5_NncaseVectorizeTx_add_rule__fold_nop_pack__352078ef10d74567", + "display_name": "fold_nop_pack", + "rule_name": "fold_nop_pack", + "callee": "NncaseVectorizeTx::add_rule", + "file": "src/benchmarks/nncase_vectorize_microbenchmark.rs", + "offset": 8135, + "line": 288, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 8135, + "end": 8693 + }, + "pattern_range": { + "start": 8209, + "end": 8610 + }, + "action_range": { + "start": 8620, + "end": 8686 + } + }, + "nodes": [ + { + "id": "inner", + "kind": "query_leaf", + "dsl_type": "VectorizeExpr", + "label": "inner: VectorizeExpr", + "range": { + "start": 8226, + "end": 8266 + }, + "inputs": [] + }, + { + "id": "layout", + "kind": "query_leaf", + "dsl_type": "LayoutTag", + "label": "layout: LayoutTag", + "range": { + "start": 8279, + "end": 8316 + }, + "inputs": [] + }, + { + "id": "unpack", + "kind": "query", + "dsl_type": "Unpack", + "label": "unpack: Unpack", + "range": { + "start": 8329, + "end": 8373 + }, + "inputs": [ + "inner", + "layout" + ] + }, + { + "id": "pack", + "kind": "query", + "dsl_type": "Pack", + "label": "pack: Pack", + "range": { + "start": 8386, + "end": 8427 + }, + "inputs": [ + "unpack", + "layout" + ] + } + ], + "edges": [ + { + "from": "unpack", + "to": "inner", + "kind": "operand", + "index": 0 + }, + { + "from": "unpack", + "to": "layout", + "kind": "operand", + "index": 1 + }, + { + "from": "pack", + "to": "unpack", + "kind": "operand", + "index": 0 + }, + { + "from": "pack", + "to": "layout", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "inner", + "pack", + "inner", + "pack" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@8645:8675", + "bound_var": null, + "source_text": "ctx.union(pat.pack, pat.inner)", + "semantic_text": null, + "referenced_pat_vars": [ + "inner", + "pack" + ], + "referenced_action_vars": [], + "range": { + "start": 8645, + "end": 8675 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "VectorizeInput", + "template": "{name}", + "fields": [ + "name" + ] + } + ], + "typst_templates": [ + { + "variant_name": "Flat", + "template": "f", + "fields": [] + }, + { + "variant_name": "Blocked", + "template": "b", + "fields": [] + }, + { + "variant_name": "VectorizeInput", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "LogicalMatMul", + "template": "({lhs} * {rhs})", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "LogicalExp", + "template": "e^({inner})", + "fields": [ + "inner" + ] + }, + { + "variant_name": "Pack", + "template": "({inner})_({layout})", + "fields": [ + "inner", + "layout" + ] + }, + { + "variant_name": "Unpack", + "template": "({inner})^({layout})", + "fields": [ + "inner", + "layout" + ] + }, + { + "variant_name": "PackedMatMul", + "template": "(({lhs} * {rhs}))_({layout})", + "fields": [ + "lhs", + "rhs", + "layout" + ] + }, + { + "variant_name": "PackedExp", + "template": "(e^({inner}))_({layout})", + "fields": [ + "inner", + "layout" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Flat", + "precedence": 100 + }, + { + "variant_name": "Blocked", + "precedence": 100 + }, + { + "variant_name": "VectorizeInput", + "precedence": 100 + }, + { + "variant_name": "LogicalMatMul", + "precedence": 50 + }, + { + "variant_name": "LogicalExp", + "precedence": 90 + }, + { + "variant_name": "Pack", + "precedence": 90 + }, + { + "variant_name": "Unpack", + "precedence": 90 + }, + { + "variant_name": "PackedMatMul", + "precedence": 50 + }, + { + "variant_name": "PackedExp", + "precedence": 90 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "fold_nop_pack", + "premises": [ + { + "target_id": "pack", + "label": "pack: Pack", + "plain_source": "(((upright(\"inner\"))^(upright(\"layout\"))))upright(\"_\")(upright(\"layout\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ ((#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $])^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $]))upright(\"_\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $]" + }, + { + "target_id": "pack", + "label": "pack: Pack", + "plain_source": "(((upright(\"inner\"))^(upright(\"layout\"))))upright(\"_\")(upright(\"layout\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ ((#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $])^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $]))upright(\"_\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_0", + "from": { + "target_id": "pack", + "label": "pack: Pack", + "plain_source": "(((upright(\"inner\"))^(upright(\"layout\"))))upright(\"_\")(upright(\"layout\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ ((#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $])^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $]))upright(\"_\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $]" + }, + "to": { + "target_id": "inner", + "label": "inner: VectorizeExpr", + "plain_source": "upright(\"inner\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]" + } + } + ], + "formula_source": { + "plain": "frac((((upright(\"inner\"))^(upright(\"layout\"))))upright(\"_\")(upright(\"layout\")) \\ (((upright(\"inner\"))^(upright(\"layout\"))))upright(\"_\")(upright(\"layout\")), (((upright(\"inner\"))^(upright(\"layout\"))))upright(\"_\")(upright(\"layout\")) arrow.r.double upright(\"inner\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ ((#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $])^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $]))upright(\"_\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ ((#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $])^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $]))upright(\"_\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ ((#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $])^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $]))upright(\"_\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $] arrow.r.double #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_benchmarks_nncase_vectorize_microbenchmark_rs__308_5_NncaseVectorizeTx_add_rule__fold_nop_unpack__36616df8b7b1df17", + "display_name": "fold_nop_unpack", + "rule_name": "fold_nop_unpack", + "callee": "NncaseVectorizeTx::add_rule", + "file": "src/benchmarks/nncase_vectorize_microbenchmark.rs", + "offset": 8700, + "line": 308, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 8700, + "end": 9266 + }, + "pattern_range": { + "start": 8776, + "end": 9181 + }, + "action_range": { + "start": 9191, + "end": 9259 + } + }, + "nodes": [ + { + "id": "inner", + "kind": "query_leaf", + "dsl_type": "VectorizeExpr", + "label": "inner: VectorizeExpr", + "range": { + "start": 8793, + "end": 8833 + }, + "inputs": [] + }, + { + "id": "layout", + "kind": "query_leaf", + "dsl_type": "LayoutTag", + "label": "layout: LayoutTag", + "range": { + "start": 8846, + "end": 8883 + }, + "inputs": [] + }, + { + "id": "pack", + "kind": "query", + "dsl_type": "Pack", + "label": "pack: Pack", + "range": { + "start": 8896, + "end": 8936 + }, + "inputs": [ + "inner", + "layout" + ] + }, + { + "id": "unpack", + "kind": "query", + "dsl_type": "Unpack", + "label": "unpack: Unpack", + "range": { + "start": 8949, + "end": 8992 + }, + "inputs": [ + "pack", + "layout" + ] + } + ], + "edges": [ + { + "from": "pack", + "to": "inner", + "kind": "operand", + "index": 0 + }, + { + "from": "pack", + "to": "layout", + "kind": "operand", + "index": 1 + }, + { + "from": "unpack", + "to": "pack", + "kind": "operand", + "index": 0 + }, + { + "from": "unpack", + "to": "layout", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "inner", + "unpack", + "inner", + "unpack" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@9216:9248", + "bound_var": null, + "source_text": "ctx.union(pat.unpack, pat.inner)", + "semantic_text": null, + "referenced_pat_vars": [ + "inner", + "unpack" + ], + "referenced_action_vars": [], + "range": { + "start": 9216, + "end": 9248 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "VectorizeInput", + "template": "{name}", + "fields": [ + "name" + ] + } + ], + "typst_templates": [ + { + "variant_name": "Flat", + "template": "f", + "fields": [] + }, + { + "variant_name": "Blocked", + "template": "b", + "fields": [] + }, + { + "variant_name": "VectorizeInput", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "LogicalMatMul", + "template": "({lhs} * {rhs})", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "LogicalExp", + "template": "e^({inner})", + "fields": [ + "inner" + ] + }, + { + "variant_name": "Pack", + "template": "({inner})_({layout})", + "fields": [ + "inner", + "layout" + ] + }, + { + "variant_name": "Unpack", + "template": "({inner})^({layout})", + "fields": [ + "inner", + "layout" + ] + }, + { + "variant_name": "PackedMatMul", + "template": "(({lhs} * {rhs}))_({layout})", + "fields": [ + "lhs", + "rhs", + "layout" + ] + }, + { + "variant_name": "PackedExp", + "template": "(e^({inner}))_({layout})", + "fields": [ + "inner", + "layout" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Flat", + "precedence": 100 + }, + { + "variant_name": "Blocked", + "precedence": 100 + }, + { + "variant_name": "VectorizeInput", + "precedence": 100 + }, + { + "variant_name": "LogicalMatMul", + "precedence": 50 + }, + { + "variant_name": "LogicalExp", + "precedence": 90 + }, + { + "variant_name": "Pack", + "precedence": 90 + }, + { + "variant_name": "Unpack", + "precedence": 90 + }, + { + "variant_name": "PackedMatMul", + "precedence": 50 + }, + { + "variant_name": "PackedExp", + "precedence": 90 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "fold_nop_unpack", + "premises": [ + { + "target_id": "unpack", + "label": "unpack: Unpack", + "plain_source": "(((upright(\"inner\"))upright(\"_\")(upright(\"layout\"))))^(upright(\"layout\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ ((#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $])upright(\"_\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $]))^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $]" + }, + { + "target_id": "unpack", + "label": "unpack: Unpack", + "plain_source": "(((upright(\"inner\"))upright(\"_\")(upright(\"layout\"))))^(upright(\"layout\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ ((#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $])upright(\"_\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $]))^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_0", + "from": { + "target_id": "unpack", + "label": "unpack: Unpack", + "plain_source": "(((upright(\"inner\"))upright(\"_\")(upright(\"layout\"))))^(upright(\"layout\"))", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ ((#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $])upright(\"_\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $]))^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $]" + }, + "to": { + "target_id": "inner", + "label": "inner: VectorizeExpr", + "plain_source": "upright(\"inner\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]" + } + } + ], + "formula_source": { + "plain": "frac((((upright(\"inner\"))upright(\"_\")(upright(\"layout\"))))^(upright(\"layout\")) \\ (((upright(\"inner\"))upright(\"_\")(upright(\"layout\"))))^(upright(\"layout\")), (((upright(\"inner\"))upright(\"_\")(upright(\"layout\"))))^(upright(\"layout\")) arrow.r.double upright(\"inner\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ ((#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $])upright(\"_\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $]))^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ ((#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $])upright(\"_\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $]))^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $], #text(fill: rgb(\"#5F7A8A\"))[$ ((#text(fill: rgb(\"#5F7A8A\"))[$ (#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $])upright(\"_\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $]))^(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"layout\") $]) $] arrow.r.double #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"inner\") $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_benchmarks_nncase_vectorize_microbenchmark_rs__331_5_NncaseVectorizeTx_add_rule__seed_name__df6802f34fdc8d96", + "display_name": "seed_name @ src/benchmarks/nncase_vectorize_microbenchmark.rs:331", + "rule_name": "seed_name", + "callee": "NncaseVectorizeTx::add_rule", + "file": "src/benchmarks/nncase_vectorize_microbenchmark.rs", + "offset": 9375, + "line": 331, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 9375, + "end": 10295 + }, + "pattern_range": { + "start": 9445, + "end": 9526 + }, + "action_range": { + "start": 9536, + "end": 10288 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Unit" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@9570:9612", + "bound_var": "q", + "source_text": "ctx.insert_vectorize_input(\"q\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 9570, + "end": 9612 + } + }, + { + "id": "effect_1", + "effect_id": "effect@9634:9676", + "bound_var": "k", + "source_text": "ctx.insert_vectorize_input(\"k\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 9634, + "end": 9676 + } + }, + { + "id": "effect_2", + "effect_id": "effect@9698:9740", + "bound_var": "v", + "source_text": "ctx.insert_vectorize_input(\"v\".to_owned())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 9698, + "end": 9740 + } + }, + { + "id": "effect_3", + "effect_id": "effect@9768:9788", + "bound_var": "blocked", + "source_text": "ctx.insert_blocked()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 9768, + "end": 9788 + } + }, + { + "id": "effect_4", + "effect_id": "effect@9817:9849", + "bound_var": "inner_mm", + "source_text": "ctx.insert_logical_mat_mul(q, k)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "k", + "q" + ], + "range": { + "start": 9817, + "end": 9849 + } + }, + { + "id": "effect_5", + "effect_id": "effect@9873:9905", + "bound_var": "exp", + "source_text": "ctx.insert_logical_exp(inner_mm)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "inner_mm" + ], + "range": { + "start": 9873, + "end": 9905 + } + }, + { + "id": "effect_6", + "effect_id": "effect@9919:9953", + "bound_var": null, + "source_text": "ctx.insert_logical_mat_mul(exp, v)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "exp", + "v" + ], + "range": { + "start": 9919, + "end": 9953 + } + }, + { + "id": "effect_7", + "effect_id": "effect@9984:10013", + "bound_var": "unpacked_q", + "source_text": "ctx.insert_unpack(q, blocked)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "blocked", + "q" + ], + "range": { + "start": 9984, + "end": 10013 + } + }, + { + "id": "effect_8", + "effect_id": "effect@10027:10061", + "bound_var": null, + "source_text": "ctx.insert_logical_exp(unpacked_q)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "unpacked_q" + ], + "range": { + "start": 10027, + "end": 10061 + } + }, + { + "id": "effect_9", + "effect_id": "effect@10090:10117", + "bound_var": "packed_k", + "source_text": "ctx.insert_pack(k, blocked)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "blocked", + "k" + ], + "range": { + "start": 10090, + "end": 10117 + } + }, + { + "id": "effect_10", + "effect_id": "effect@10131:10167", + "bound_var": null, + "source_text": "ctx.insert_unpack(packed_k, blocked)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "blocked", + "packed_k" + ], + "range": { + "start": 10131, + "end": 10167 + } + }, + { + "id": "effect_11", + "effect_id": "effect@10198:10227", + "bound_var": "unpacked_v", + "source_text": "ctx.insert_unpack(v, blocked)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "blocked", + "v" + ], + "range": { + "start": 10198, + "end": 10227 + } + }, + { + "id": "effect_12", + "effect_id": "effect@10241:10277", + "bound_var": null, + "source_text": "ctx.insert_pack(unpacked_v, blocked)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "blocked", + "unpacked_v" + ], + "range": { + "start": 10241, + "end": 10277 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "VectorizeInput", + "template": "{name}", + "fields": [ + "name" + ] + } + ], + "typst_templates": [ + { + "variant_name": "Flat", + "template": "f", + "fields": [] + }, + { + "variant_name": "Blocked", + "template": "b", + "fields": [] + }, + { + "variant_name": "VectorizeInput", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "LogicalMatMul", + "template": "({lhs} * {rhs})", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "LogicalExp", + "template": "e^({inner})", + "fields": [ + "inner" + ] + }, + { + "variant_name": "Pack", + "template": "({inner})_({layout})", + "fields": [ + "inner", + "layout" + ] + }, + { + "variant_name": "Unpack", + "template": "({inner})^({layout})", + "fields": [ + "inner", + "layout" + ] + }, + { + "variant_name": "PackedMatMul", + "template": "(({lhs} * {rhs}))_({layout})", + "fields": [ + "lhs", + "rhs", + "layout" + ] + }, + { + "variant_name": "PackedExp", + "template": "(e^({inner}))_({layout})", + "fields": [ + "inner", + "layout" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "Flat", + "precedence": 100 + }, + { + "variant_name": "Blocked", + "precedence": 100 + }, + { + "variant_name": "VectorizeInput", + "precedence": 100 + }, + { + "variant_name": "LogicalMatMul", + "precedence": 50 + }, + { + "variant_name": "LogicalExp", + "precedence": 90 + }, + { + "variant_name": "Pack", + "precedence": 90 + }, + { + "variant_name": "Unpack", + "precedence": 90 + }, + { + "variant_name": "PackedMatMul", + "precedence": 50 + }, + { + "variant_name": "PackedExp", + "precedence": 90 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "rule@9375", + "premises": [ + { + "target_id": "Unit", + "label": "Unit", + "plain_source": "upright(\"Unit\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"Unit\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_test_rs__173_9_MyTx_add_rule__my_rule__956649a1be08abce", + "display_name": "my_rule", + "rule_name": "my_rule", + "callee": "MyTx::add_rule", + "file": "src/test.rs", + "offset": 4706, + "line": 173, + "column": 9, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 4706, + "end": 4928 + }, + "pattern_range": { + "start": 4741, + "end": 4747 + }, + "action_range": { + "start": 4749, + "end": 4927 + } + }, + "nodes": [ + { + "id": "expr_var", + "kind": "query_leaf", + "dsl_type": "Expr", + "label": "expr_var: Expr", + "range": { + "start": 2271, + "end": 2305 + }, + "inputs": [] + }, + { + "id": "_root", + "kind": "query", + "dsl_type": "GraphRoot", + "label": "_root: GraphRoot", + "range": { + "start": 2314, + "end": 2354 + }, + "inputs": [ + "expr_var" + ] + } + ], + "edges": [ + { + "from": "_root", + "to": "expr_var", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "expr_var" + ], + "constraints": [], + "action_effects": [], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "root.commit()", + "committed_root": "root", + "referenced_vars": [ + "root" + ], + "range": { + "start": 4530, + "end": 4543 + } + } + ], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "my_rule", + "premises": [ + { + "target_id": "expr_var", + "label": "expr_var: Expr", + "plain_source": "upright(\"expr_var\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr_var\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"expr_var\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr_var\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_test_rs__192_9_RelTx_add_rule__seed_path__14849b83d09ab9c8", + "display_name": "seed_path @ src/test.rs:192", + "rule_name": "seed_path", + "callee": "RelTx::add_rule", + "file": "src/test.rs", + "offset": 5383, + "line": 192, + "column": 9, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 5383, + "end": 5906 + }, + "pattern_range": { + "start": 5458, + "end": 5647 + }, + "action_range": { + "start": 5661, + "end": 5895 + } + }, + "nodes": [ + { + "id": "edge", + "kind": "query", + "dsl_type": "RelEdge", + "label": "edge: RelEdge", + "range": { + "start": 5479, + "end": 5507 + }, + "inputs": [] + } + ], + "edges": [], + "roots": [ + "edge" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@5796:5825", + "bound_var": null, + "source_text": "ctx.insert_rel_path(src, dst)", + "semantic_text": null, + "referenced_pat_vars": [ + "edge" + ], + "referenced_action_vars": [ + "dst", + "src" + ], + "range": { + "start": 5796, + "end": 5825 + } + }, + { + "id": "effect_1", + "effect_id": "effect@5843:5880", + "bound_var": null, + "source_text": "ctx.set_rel_path_mark(src, dst, true)", + "semantic_text": "rel_path_mark(src, dst) = true", + "referenced_pat_vars": [ + "edge" + ], + "referenced_action_vars": [ + "dst", + "src" + ], + "range": { + "start": 5843, + "end": 5880 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "RelEdge::::insert(1, 2)", + "committed_root": "RelEdge::", + "referenced_vars": [], + "range": { + "start": 5237, + "end": 5267 + } + }, + { + "id": "seed_1", + "source_text": "RelEdge::::insert(2, 3)", + "committed_root": "RelEdge::", + "referenced_vars": [], + "range": { + "start": 5277, + "end": 5307 + } + } + ], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "seed_path", + "premises": [ + { + "target_id": "edge", + "label": "edge: RelEdge", + "plain_source": "upright(\"edge\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"edge\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "effect_1", + "plain_source": "upright(\"rel_path_mark\")(upright(\"src\"), upright(\"dst\")) = upright(\"true\")", + "colored_source": "upright(\"rel_path_mark\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"src\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"dst\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"true\") $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"edge\"), upright(\"rel_path_mark\")(upright(\"src\"), upright(\"dst\")) = upright(\"true\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"edge\") $], upright(\"rel_path_mark\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"src\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"dst\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"true\") $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_test_rs__209_9_RelTx_add_rule__extend_path__d7cc1333b490f8b2", + "display_name": "extend_path @ src/test.rs:209", + "rule_name": "extend_path", + "callee": "RelTx::add_rule", + "file": "src/test.rs", + "offset": 5916, + "line": 209, + "column": 9, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 5916, + "end": 6634 + }, + "pattern_range": { + "start": 5993, + "end": 6375 + }, + "action_range": { + "start": 6389, + "end": 6623 + } + }, + "nodes": [ + { + "id": "path", + "kind": "query", + "dsl_type": "RelPath", + "label": "path: RelPath", + "range": { + "start": 6014, + "end": 6042 + }, + "inputs": [] + }, + { + "id": "edge", + "kind": "query", + "dsl_type": "RelEdge", + "label": "edge: RelEdge", + "range": { + "start": 6059, + "end": 6087 + }, + "inputs": [] + } + ], + "edges": [], + "roots": [ + "path", + "edge", + "path", + "edge" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "join", + "resolved_text": "path.handle_dst().eq(&edge.handle_src())", + "semantic_text": "path.dst == edge.src", + "referenced_vars": [ + "edge", + "path" + ], + "range": { + "start": 6356, + "end": 6360 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@6524:6553", + "bound_var": null, + "source_text": "ctx.insert_rel_path(src, dst)", + "semantic_text": null, + "referenced_pat_vars": [ + "edge", + "path" + ], + "referenced_action_vars": [ + "dst", + "src" + ], + "range": { + "start": 6524, + "end": 6553 + } + }, + { + "id": "effect_1", + "effect_id": "effect@6571:6608", + "bound_var": null, + "source_text": "ctx.set_rel_path_mark(src, dst, true)", + "semantic_text": "rel_path_mark(src, dst) = true", + "referenced_pat_vars": [ + "edge", + "path" + ], + "referenced_action_vars": [ + "dst", + "src" + ], + "range": { + "start": 6571, + "end": 6608 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "RelEdge::::insert(1, 2)", + "committed_root": "RelEdge::", + "referenced_vars": [], + "range": { + "start": 5237, + "end": 5267 + } + }, + { + "id": "seed_1", + "source_text": "RelEdge::::insert(2, 3)", + "committed_root": "RelEdge::", + "referenced_vars": [], + "range": { + "start": 5277, + "end": 5307 + } + } + ], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "extend_path", + "premises": [ + { + "target_id": "path", + "label": "path: RelPath", + "plain_source": "upright(\"path\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"path\") $]" + }, + { + "target_id": "edge", + "label": "edge: RelEdge", + "plain_source": "upright(\"edge\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"edge\") $]" + }, + { + "target_id": "path", + "label": "path: RelPath", + "plain_source": "upright(\"path\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"path\") $]" + }, + { + "target_id": "edge", + "label": "edge: RelEdge", + "plain_source": "upright(\"edge\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"edge\") $]" + } + ], + "side_conditions": [ + "upright(\"path.dst\") == upright(\"edge.src\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "effect_1", + "plain_source": "upright(\"rel_path_mark\")(upright(\"src\"), upright(\"dst\")) = upright(\"true\")", + "colored_source": "upright(\"rel_path_mark\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"src\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"dst\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"true\") $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"path\") \\ upright(\"edge\") \\ upright(\"path\") \\ upright(\"edge\"), upright(\"rel_path_mark\")(upright(\"src\"), upright(\"dst\")) = upright(\"true\")) quad upright(\"if\") quad upright(\"path.dst\") == upright(\"edge.src\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"path\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"edge\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"path\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"edge\") $], upright(\"rel_path_mark\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"src\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"dst\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"true\") $]) quad upright(\"if\") quad upright(\"path.dst\") == upright(\"edge.src\")" + } + } + } + }, + { + "id": "src_test_rs__282_9_RelHandleTx_add_rule__mark_increasing_edge__164b2aada963ff96", + "display_name": "mark_increasing_edge", + "rule_name": "mark_increasing_edge", + "callee": "RelHandleTx::add_rule", + "file": "src/test.rs", + "offset": 7994, + "line": 282, + "column": 9, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 7994, + "end": 8614 + }, + "pattern_range": { + "start": 8086, + "end": 8394 + }, + "action_range": { + "start": 8408, + "end": 8603 + } + }, + "nodes": [ + { + "id": "edge", + "kind": "query", + "dsl_type": "RelEdge", + "label": "edge: RelEdge", + "range": { + "start": 8107, + "end": 8135 + }, + "inputs": [] + } + ], + "edges": [], + "roots": [ + "edge", + "edge" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "increasing", + "resolved_text": "edge.handle_src().lt(&edge.handle_dst())", + "semantic_text": "edge.src < edge.dst", + "referenced_vars": [ + "edge" + ], + "range": { + "start": 8369, + "end": 8379 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@8543:8588", + "bound_var": null, + "source_text": "ctx.set_rel_handle_sugar_mark(src, dst, true)", + "semantic_text": "rel_handle_sugar_mark(src, dst) = true", + "referenced_pat_vars": [ + "edge" + ], + "referenced_action_vars": [ + "dst", + "src" + ], + "range": { + "start": 8543, + "end": 8588 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "RelEdge::::insert(11, 13)", + "committed_root": "RelEdge::", + "referenced_vars": [], + "range": { + "start": 7819, + "end": 7857 + } + }, + { + "id": "seed_1", + "source_text": "RelEdge::::insert(17, 5)", + "committed_root": "RelEdge::", + "referenced_vars": [], + "range": { + "start": 7867, + "end": 7904 + } + } + ], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "mark_increasing_edge", + "premises": [ + { + "target_id": "edge", + "label": "edge: RelEdge", + "plain_source": "upright(\"edge\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"edge\") $]" + }, + { + "target_id": "edge", + "label": "edge: RelEdge", + "plain_source": "upright(\"edge\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"edge\") $]" + } + ], + "side_conditions": [ + "upright(\"edge.src\") < upright(\"edge.dst\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "effect_0", + "plain_source": "upright(\"rel_handle_sugar_mark\")(upright(\"src\"), upright(\"dst\")) = upright(\"true\")", + "colored_source": "upright(\"rel_handle_sugar_mark\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"src\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"dst\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"true\") $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"edge\") \\ upright(\"edge\"), upright(\"rel_handle_sugar_mark\")(upright(\"src\"), upright(\"dst\")) = upright(\"true\")) quad upright(\"if\") quad upright(\"edge.src\") < upright(\"edge.dst\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"edge\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"edge\") $], upright(\"rel_handle_sugar_mark\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"src\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"dst\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"true\") $]) quad upright(\"if\") quad upright(\"edge.src\") < upright(\"edge.dst\")" + } + } + } + }, + { + "id": "src_test_rs__320_9_RelMixedTx_add_rule__seed_owns__f65f058c1393f17a", + "display_name": "seed_owns", + "rule_name": "seed_owns", + "callee": "RelMixedTx::add_rule", + "file": "src/test.rs", + "offset": 9277, + "line": 320, + "column": 9, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 9277, + "end": 9594 + }, + "pattern_range": { + "start": 9357, + "end": 9449 + }, + "action_range": { + "start": 9463, + "end": 9583 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Pat" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@9502:9521", + "bound_var": "alice", + "source_text": "ctx.insert_human(1)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 9502, + "end": 9521 + } + }, + { + "id": "effect_1", + "effect_id": "effect@9539:9568", + "bound_var": null, + "source_text": "ctx.insert_rel_owns(alice, 7)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "alice" + ], + "range": { + "start": 9539, + "end": 9568 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "seed_owns", + "premises": [ + { + "target_id": "Pat", + "label": "Pat", + "plain_source": "upright(\"Pat\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Pat\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"Pat\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Pat\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_test_rs__332_9_RelMixedTx_add_rule__mark_owns__ef9fcb8dd3f66547", + "display_name": "mark_owns", + "rule_name": "mark_owns", + "callee": "RelMixedTx::add_rule", + "file": "src/test.rs", + "offset": 9604, + "line": 332, + "column": 9, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 9604, + "end": 10048 + }, + "pattern_range": { + "start": 9684, + "end": 9948 + }, + "action_range": { + "start": 9962, + "end": 10037 + } + }, + "nodes": [ + { + "id": "owner", + "kind": "query", + "dsl_type": "Human", + "label": "owner: Human", + "range": { + "start": 9705, + "end": 9732 + }, + "inputs": [] + }, + { + "id": "owns", + "kind": "query", + "dsl_type": "RelOwns", + "label": "owns: RelOwns", + "range": { + "start": 9749, + "end": 9783 + }, + "inputs": [ + "owner" + ] + } + ], + "edges": [ + { + "from": "owns", + "to": "owner", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "owns", + "owns" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@9989:10022", + "bound_var": null, + "source_text": "ctx.set_rel_owns_mark(1, 7, true)", + "semantic_text": "rel_owns_mark(1, 7) = true", + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 9989, + "end": 10022 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "mark_owns", + "premises": [ + { + "target_id": "owns", + "label": "owns: RelOwns", + "plain_source": "upright(\"RelOwns\")(upright(\"owner\"))", + "colored_source": "upright(\"RelOwns\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"owner\") $])" + }, + { + "target_id": "owns", + "label": "owns: RelOwns", + "plain_source": "upright(\"RelOwns\")(upright(\"owner\"))", + "colored_source": "upright(\"RelOwns\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"owner\") $])" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "effect_0", + "plain_source": "upright(\"rel_owns_mark\")(1, 7) = upright(\"true\")", + "colored_source": "upright(\"rel_owns_mark\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $], #text(fill: rgb(\"#B86A5B\"))[$ 7 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"true\") $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"RelOwns\")(upright(\"owner\")) \\ upright(\"RelOwns\")(upright(\"owner\")), upright(\"rel_owns_mark\")(1, 7) = upright(\"true\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"RelOwns\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"owner\") $]) \\ upright(\"RelOwns\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"owner\") $]), upright(\"rel_owns_mark\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $], #text(fill: rgb(\"#B86A5B\"))[$ 7 $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"true\") $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_test_rs__368_9_RelComplexTx_add_rule__seed_friend__25a4d28ad0d875b4", + "display_name": "seed_friend", + "rule_name": "seed_friend", + "callee": "RelComplexTx::add_rule", + "file": "src/test.rs", + "offset": 10706, + "line": 368, + "column": 9, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 10706, + "end": 11078 + }, + "pattern_range": { + "start": 10790, + "end": 10882 + }, + "action_range": { + "start": 10896, + "end": 11067 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Pat" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@10935:10954", + "bound_var": "alice", + "source_text": "ctx.insert_human(1)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 10935, + "end": 10954 + } + }, + { + "id": "effect_1", + "effect_id": "effect@10982:11001", + "bound_var": "bob", + "source_text": "ctx.insert_human(2)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 10982, + "end": 11001 + } + }, + { + "id": "effect_2", + "effect_id": "effect@11019:11052", + "bound_var": null, + "source_text": "ctx.insert_rel_friend(alice, bob)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "alice", + "bob" + ], + "range": { + "start": 11019, + "end": 11052 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "seed_friend", + "premises": [ + { + "target_id": "Pat", + "label": "Pat", + "plain_source": "upright(\"Pat\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Pat\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"Pat\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Pat\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_test_rs__381_9_RelComplexTx_add_rule__mark_friend__8d25b3572448849f", + "display_name": "mark_friend", + "rule_name": "mark_friend", + "callee": "RelComplexTx::add_rule", + "file": "src/test.rs", + "offset": 11088, + "line": 381, + "column": 9, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 11088, + "end": 12075 + }, + "pattern_range": { + "start": 11172, + "end": 11844 + }, + "action_range": { + "start": 11858, + "end": 12064 + } + }, + "nodes": [ + { + "id": "left", + "kind": "query", + "dsl_type": "Human", + "label": "left: Human", + "range": { + "start": 11193, + "end": 11219 + }, + "inputs": [] + }, + { + "id": "right", + "kind": "query", + "dsl_type": "Human", + "label": "right: Human", + "range": { + "start": 11236, + "end": 11263 + }, + "inputs": [] + }, + { + "id": "friend", + "kind": "query", + "dsl_type": "RelFriend", + "label": "friend: RelFriend", + "range": { + "start": 11280, + "end": 11325 + }, + "inputs": [ + "left", + "right" + ] + } + ], + "edges": [ + { + "from": "friend", + "to": "left", + "kind": "operand", + "index": 0 + }, + { + "from": "friend", + "to": "right", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "left", + "right", + "friend", + "left", + "right", + "friend" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "friend_left_matches", + "resolved_text": "friend.left.handle().eq(&left.handle())", + "semantic_text": "friend.left == left", + "referenced_vars": [ + "friend", + "left" + ], + "range": { + "start": 11760, + "end": 11779 + } + }, + { + "id": "constraint_1", + "source_text": "friend_right_matches", + "resolved_text": "friend.right.handle().eq(&right.handle())", + "semantic_text": "friend.right == right", + "referenced_vars": [ + "friend", + "right" + ], + "range": { + "start": 11809, + "end": 11829 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@12001:12049", + "bound_var": null, + "source_text": "ctx.set_rel_friend_mark(left_id, right_id, true)", + "semantic_text": "rel_friend_mark(left_id, right_id) = true", + "referenced_pat_vars": [ + "left", + "right" + ], + "referenced_action_vars": [ + "left_id", + "right_id" + ], + "range": { + "start": 12001, + "end": 12049 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "mark_friend", + "premises": [ + { + "target_id": "left", + "label": "left: Human", + "plain_source": "upright(\"left\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left\") $]" + }, + { + "target_id": "right", + "label": "right: Human", + "plain_source": "upright(\"right\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right\") $]" + }, + { + "target_id": "friend", + "label": "friend: RelFriend", + "plain_source": "upright(\"RelFriend\")(upright(\"left\"), upright(\"right\"))", + "colored_source": "upright(\"RelFriend\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right\") $])" + }, + { + "target_id": "left", + "label": "left: Human", + "plain_source": "upright(\"left\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left\") $]" + }, + { + "target_id": "right", + "label": "right: Human", + "plain_source": "upright(\"right\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right\") $]" + }, + { + "target_id": "friend", + "label": "friend: RelFriend", + "plain_source": "upright(\"RelFriend\")(upright(\"left\"), upright(\"right\"))", + "colored_source": "upright(\"RelFriend\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right\") $])" + } + ], + "side_conditions": [ + "upright(\"friend.left\") == upright(\"left\")", + "upright(\"friend.right\") == upright(\"right\")" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "effect_0", + "plain_source": "upright(\"rel_friend_mark\")(upright(\"left_id\"), upright(\"right_id\")) = upright(\"true\")", + "colored_source": "upright(\"rel_friend_mark\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"left_id\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"right_id\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"true\") $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"left\") \\ upright(\"right\") \\ upright(\"RelFriend\")(upright(\"left\"), upright(\"right\")) \\ upright(\"left\") \\ upright(\"right\") \\ upright(\"RelFriend\")(upright(\"left\"), upright(\"right\")), upright(\"rel_friend_mark\")(upright(\"left_id\"), upright(\"right_id\")) = upright(\"true\")) quad upright(\"if\") quad upright(\"friend.left\") == upright(\"left\") \\ upright(\"friend.right\") == upright(\"right\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right\") $] \\ upright(\"RelFriend\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right\") $] \\ upright(\"RelFriend\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right\") $]), upright(\"rel_friend_mark\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"left_id\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"right_id\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"true\") $]) quad upright(\"if\") quad upright(\"friend.left\") == upright(\"left\") \\ upright(\"friend.right\") == upright(\"right\")" + } + } + } + }, + { + "id": "src_test_rs__432_9_RelTransferTx_add_rule__seed_story__08d1f6cc94c9410a", + "display_name": "seed_story @ src/test.rs:432", + "rule_name": "seed_story", + "callee": "RelTransferTx::add_rule", + "file": "src/test.rs", + "offset": 12890, + "line": 432, + "column": 9, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 12890, + "end": 13467 + }, + "pattern_range": { + "start": 12974, + "end": 13067 + }, + "action_range": { + "start": 13081, + "end": 13456 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Unit" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@13120:13146", + "bound_var": "alice", + "source_text": "ctx.insert_human(ALICE_ID)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 13120, + "end": 13146 + } + }, + { + "id": "effect_1", + "effect_id": "effect@13174:13198", + "bound_var": "bob", + "source_text": "ctx.insert_human(BOB_ID)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 13174, + "end": 13198 + } + }, + { + "id": "effect_2", + "effect_id": "effect@13228:13254", + "bound_var": "carol", + "source_text": "ctx.insert_human(CAROL_ID)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 13228, + "end": 13254 + } + }, + { + "id": "effect_3", + "effect_id": "effect@13272:13316", + "bound_var": null, + "source_text": "ctx.insert_rel_transfer_owns(alice, RING_ID)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "alice" + ], + "range": { + "start": 13272, + "end": 13316 + } + }, + { + "id": "effect_4", + "effect_id": "effect@13334:13378", + "bound_var": null, + "source_text": "ctx.insert_rel_transfer_owns(carol, BOOK_ID)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "carol" + ], + "range": { + "start": 13334, + "end": 13378 + } + }, + { + "id": "effect_5", + "effect_id": "effect@13396:13441", + "bound_var": null, + "source_text": "ctx.insert_rel_transfer_request(bob, RING_ID)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "bob" + ], + "range": { + "start": 13396, + "end": 13441 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "seed_story", + "premises": [ + { + "target_id": "Unit", + "label": "Unit", + "plain_source": "upright(\"Unit\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"Unit\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_test_rs__448_9_RelTransferTx_add_rule__mark_ownership__6cafea2468d54f09", + "display_name": "mark_ownership @ src/test.rs:448", + "rule_name": "mark_ownership", + "callee": "RelTransferTx::add_rule", + "file": "src/test.rs", + "offset": 13477, + "line": 448, + "column": 9, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 13477, + "end": 14019 + }, + "pattern_range": { + "start": 13565, + "end": 13979 + }, + "action_range": { + "start": 13993, + "end": 14008 + } + }, + "nodes": [ + { + "id": "owner", + "kind": "query", + "dsl_type": "Human", + "label": "owner: Human", + "range": { + "start": 13586, + "end": 13613 + }, + "inputs": [] + }, + { + "id": "owns", + "kind": "query", + "dsl_type": "RelTransferOwns", + "label": "owns: RelTransferOwns", + "range": { + "start": 13630, + "end": 13672 + }, + "inputs": [ + "owner" + ] + } + ], + "edges": [ + { + "from": "owns", + "to": "owner", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "owns", + "owner", + "owns", + "owner" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "same_owner", + "resolved_text": "owns.owner.handle().eq(&owner.handle())", + "semantic_text": "owns.owner == owner", + "referenced_vars": [ + "owner", + "owns" + ], + "range": { + "start": 13954, + "end": 13964 + } + } + ], + "action_effects": [], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "mark_ownership", + "premises": [ + { + "target_id": "owns", + "label": "owns: RelTransferOwns", + "plain_source": "upright(\"RelTransferOwns\")(upright(\"owner\"))", + "colored_source": "upright(\"RelTransferOwns\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"owner\") $])" + }, + { + "target_id": "owner", + "label": "owner: Human", + "plain_source": "upright(\"owner\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"owner\") $]" + }, + { + "target_id": "owns", + "label": "owns: RelTransferOwns", + "plain_source": "upright(\"RelTransferOwns\")(upright(\"owner\"))", + "colored_source": "upright(\"RelTransferOwns\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"owner\") $])" + }, + { + "target_id": "owner", + "label": "owner: Human", + "plain_source": "upright(\"owner\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"owner\") $]" + } + ], + "side_conditions": [ + "upright(\"owns.owner\") == upright(\"owner\")" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"RelTransferOwns\")(upright(\"owner\")) \\ upright(\"owner\") \\ upright(\"RelTransferOwns\")(upright(\"owner\")) \\ upright(\"owner\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"owns.owner\") == upright(\"owner\")", + "colored": "frac(upright(\"RelTransferOwns\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"owner\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"owner\") $] \\ upright(\"RelTransferOwns\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"owner\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"owner\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"owns.owner\") == upright(\"owner\")" + } + } + } + }, + { + "id": "src_test_rs__464_9_RelTransferTx_add_rule__apply_transfer__fd4cbf3d7b1dfb2a", + "display_name": "apply_transfer @ src/test.rs:464", + "rule_name": "apply_transfer", + "callee": "RelTransferTx::add_rule", + "file": "src/test.rs", + "offset": 14029, + "line": 464, + "column": 9, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 14029, + "end": 15398 + }, + "pattern_range": { + "start": 14117, + "end": 15216 + }, + "action_range": { + "start": 15230, + "end": 15387 + } + }, + "nodes": [ + { + "id": "current_owner", + "kind": "query", + "dsl_type": "Human", + "label": "current_owner: Human", + "range": { + "start": 14138, + "end": 14173 + }, + "inputs": [] + }, + { + "id": "owns", + "kind": "query", + "dsl_type": "RelTransferOwns", + "label": "owns: RelTransferOwns", + "range": { + "start": 14190, + "end": 14240 + }, + "inputs": [ + "current_owner" + ] + }, + { + "id": "new_owner", + "kind": "query", + "dsl_type": "Human", + "label": "new_owner: Human", + "range": { + "start": 14257, + "end": 14288 + }, + "inputs": [] + }, + { + "id": "request", + "kind": "query", + "dsl_type": "RelTransferRequest", + "label": "request: RelTransferRequest", + "range": { + "start": 14305, + "end": 14357 + }, + "inputs": [ + "new_owner" + ] + } + ], + "edges": [ + { + "from": "owns", + "to": "current_owner", + "kind": "operand", + "index": 0 + }, + { + "from": "request", + "to": "new_owner", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "owns", + "current_owner", + "request", + "new_owner", + "owns", + "current_owner", + "request", + "new_owner" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "same_current_owner", + "resolved_text": "owns.owner.handle().eq(¤t_owner.handle())", + "semantic_text": "owns.owner == current_owner", + "referenced_vars": [ + "current_owner", + "owns" + ], + "range": { + "start": 15057, + "end": 15075 + } + }, + { + "id": "constraint_1", + "source_text": "same_new_owner", + "resolved_text": "request.new_owner.handle().eq(&new_owner.handle())", + "semantic_text": "request.new_owner == new_owner", + "referenced_vars": [ + "new_owner", + "request" + ], + "range": { + "start": 15105, + "end": 15119 + } + }, + { + "id": "constraint_2", + "source_text": "same_item", + "resolved_text": "owns.handle_item_id().eq(&request.handle_item_id())", + "semantic_text": "owns.item_id == request.item_id", + "referenced_vars": [ + "owns", + "request" + ], + "range": { + "start": 15149, + "end": 15158 + } + }, + { + "id": "constraint_3", + "source_text": "owner_changes", + "resolved_text": "current_owner.handle().ne(&new_owner.handle())", + "semantic_text": "current_owner != new_owner", + "referenced_vars": [ + "current_owner", + "new_owner" + ], + "range": { + "start": 15188, + "end": 15201 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@15320:15372", + "bound_var": null, + "source_text": "ctx.insert_rel_transfer_owns(pat.new_owner, item_id)", + "semantic_text": null, + "referenced_pat_vars": [ + "new_owner", + "owns" + ], + "referenced_action_vars": [ + "item_id" + ], + "range": { + "start": 15320, + "end": 15372 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "apply_transfer", + "premises": [ + { + "target_id": "owns", + "label": "owns: RelTransferOwns", + "plain_source": "upright(\"RelTransferOwns\")(upright(\"current_owner\"))", + "colored_source": "upright(\"RelTransferOwns\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"current_owner\") $])" + }, + { + "target_id": "current_owner", + "label": "current_owner: Human", + "plain_source": "upright(\"current_owner\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"current_owner\") $]" + }, + { + "target_id": "request", + "label": "request: RelTransferRequest", + "plain_source": "upright(\"RelTransferRequest\")(upright(\"new_owner\"))", + "colored_source": "upright(\"RelTransferRequest\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_owner\") $])" + }, + { + "target_id": "new_owner", + "label": "new_owner: Human", + "plain_source": "upright(\"new_owner\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_owner\") $]" + }, + { + "target_id": "owns", + "label": "owns: RelTransferOwns", + "plain_source": "upright(\"RelTransferOwns\")(upright(\"current_owner\"))", + "colored_source": "upright(\"RelTransferOwns\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"current_owner\") $])" + }, + { + "target_id": "current_owner", + "label": "current_owner: Human", + "plain_source": "upright(\"current_owner\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"current_owner\") $]" + }, + { + "target_id": "request", + "label": "request: RelTransferRequest", + "plain_source": "upright(\"RelTransferRequest\")(upright(\"new_owner\"))", + "colored_source": "upright(\"RelTransferRequest\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_owner\") $])" + }, + { + "target_id": "new_owner", + "label": "new_owner: Human", + "plain_source": "upright(\"new_owner\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_owner\") $]" + } + ], + "side_conditions": [ + "upright(\"owns.owner\") == upright(\"current_owner\")", + "upright(\"request.new_owner\") == upright(\"new_owner\")", + "upright(\"owns.item_id\") == upright(\"request.item_id\")", + "upright(\"current_owner\") != upright(\"new_owner\")" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"RelTransferOwns\")(upright(\"current_owner\")) \\ upright(\"current_owner\") \\ upright(\"RelTransferRequest\")(upright(\"new_owner\")) \\ upright(\"new_owner\") \\ upright(\"RelTransferOwns\")(upright(\"current_owner\")) \\ upright(\"current_owner\") \\ upright(\"RelTransferRequest\")(upright(\"new_owner\")) \\ upright(\"new_owner\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"owns.owner\") == upright(\"current_owner\") \\ upright(\"request.new_owner\") == upright(\"new_owner\") \\ upright(\"owns.item_id\") == upright(\"request.item_id\") \\ upright(\"current_owner\") != upright(\"new_owner\")", + "colored": "frac(upright(\"RelTransferOwns\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"current_owner\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"current_owner\") $] \\ upright(\"RelTransferRequest\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_owner\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_owner\") $] \\ upright(\"RelTransferOwns\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"current_owner\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"current_owner\") $] \\ upright(\"RelTransferRequest\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_owner\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"new_owner\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"owns.owner\") == upright(\"current_owner\") \\ upright(\"request.new_owner\") == upright(\"new_owner\") \\ upright(\"owns.item_id\") == upright(\"request.item_id\") \\ upright(\"current_owner\") != upright(\"new_owner\")" + } + } + } + }, + { + "id": "src_test_rs__1681_9_MyTx_add_rule__persisted_snapshot_ruleset_name_rule__4099aea58b6b7498", + "display_name": "persisted_snapshot_ruleset_name_rule", + "rule_name": "persisted_snapshot_ruleset_name_rule", + "callee": "MyTx::add_rule", + "file": "src/test.rs", + "offset": 57090, + "line": 1681, + "column": 9, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 57090, + "end": 57466 + }, + "pattern_range": { + "start": 57191, + "end": 57426 + }, + "action_range": { + "start": 57440, + "end": 57455 + } + }, + "nodes": [ + { + "id": "expr", + "kind": "query_leaf", + "dsl_type": "Expr", + "label": "expr: Expr", + "range": { + "start": 57212, + "end": 57242 + }, + "inputs": [] + }, + { + "id": "root", + "kind": "query", + "dsl_type": "Root", + "label": "root: Root", + "range": { + "start": 57259, + "end": 57289 + }, + "inputs": [ + "expr" + ] + } + ], + "edges": [ + { + "from": "root", + "to": "expr", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "root" + ], + "constraints": [], + "action_effects": [], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "persisted_snapshot_ruleset_name_rule", + "premises": [ + { + "target_id": "root", + "label": "root: Root", + "plain_source": "upright(\"Root\")(upright(\"expr\"))", + "colored_source": "upright(\"Root\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $])" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"Root\")(upright(\"expr\")), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"Root\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $]), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_test_rs__1728_9_MyTx_add_rule__persisted_snapshot_restore_ignores_ruleset_name_rule__8726645c1d655cfb", + "display_name": "persisted_snapshot_restore_ignores_ruleset_name_rule", + "rule_name": "persisted_snapshot_restore_ignores_ruleset_name_rule", + "callee": "MyTx::add_rule", + "file": "src/test.rs", + "offset": 58647, + "line": 1728, + "column": 9, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 58647, + "end": 59039 + }, + "pattern_range": { + "start": 58764, + "end": 58999 + }, + "action_range": { + "start": 59013, + "end": 59028 + } + }, + "nodes": [ + { + "id": "expr", + "kind": "query_leaf", + "dsl_type": "Expr", + "label": "expr: Expr", + "range": { + "start": 58785, + "end": 58815 + }, + "inputs": [] + }, + { + "id": "root", + "kind": "query", + "dsl_type": "Root", + "label": "root: Root", + "range": { + "start": 58832, + "end": 58862 + }, + "inputs": [ + "expr" + ] + } + ], + "edges": [ + { + "from": "root", + "to": "expr", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "root" + ], + "constraints": [], + "action_effects": [], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "persisted_snapshot_restore_ignores_ruleset_name_rule", + "premises": [ + { + "target_id": "root", + "label": "root: Root", + "plain_source": "upright(\"Root\")(upright(\"expr\"))", + "colored_source": "upright(\"Root\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $])" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"Root\")(upright(\"expr\")), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"Root\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $]), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_test_rs__2418_9_MyTxFunc_add_rule__seed_func__e646ae73cb061391", + "display_name": "seed_func", + "rule_name": "seed_func", + "callee": "MyTxFunc::add_rule", + "file": "src/test.rs", + "offset": 82388, + "line": 2418, + "column": 9, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 82388, + "end": 82903 + }, + "pattern_range": { + "start": 82463, + "end": 82556 + }, + "action_range": { + "start": 82570, + "end": 82892 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Unit" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@82852:82877", + "bound_var": null, + "source_text": "ctx.set_m_accum_q(sv, ev)", + "semantic_text": "m_accum_q(sv) = ev", + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 82852, + "end": 82877 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "seed_func", + "premises": [ + { + "target_id": "Unit", + "label": "Unit", + "plain_source": "upright(\"Unit\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "effect_0", + "plain_source": "upright(\"m_accum_q\")(upright(\"sv\")) = upright(\"ev\")", + "colored_source": "upright(\"m_accum_q\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"sv\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"ev\") $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"Unit\"), upright(\"m_accum_q\")(upright(\"sv\")) = upright(\"ev\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $], upright(\"m_accum_q\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"sv\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"ev\") $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_test_rs__2440_9_MyTxFunc_add_rule__match_func_output__975479185658a18a", + "display_name": "match_func_output", + "rule_name": "match_func_output", + "callee": "MyTxFunc::add_rule", + "file": "src/test.rs", + "offset": 83124, + "line": 2440, + "column": 9, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 83124, + "end": 83578 + }, + "pattern_range": { + "start": 83210, + "end": 83468 + }, + "action_range": { + "start": 83482, + "end": 83567 + } + }, + "nodes": [ + { + "id": "s", + "kind": "query_leaf", + "dsl_type": "FuncS", + "label": "s: FuncS", + "range": { + "start": 83231, + "end": 83259 + }, + "inputs": [] + }, + { + "id": "e", + "kind": "query", + "dsl_type": "MAccumQ", + "label": "e: MAccumQ", + "range": { + "start": 83276, + "end": 83303 + }, + "inputs": [ + "s" + ] + } + ], + "edges": [ + { + "from": "e", + "to": "s", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "s", + "e" + ], + "constraints": [], + "action_effects": [], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "match_func_output", + "premises": [ + { + "target_id": "e", + "label": "e: MAccumQ", + "plain_source": "upright(\"MAccumQ\")(s)", + "colored_source": "upright(\"MAccumQ\")(#text(fill: rgb(\"#5F7A8A\"))[$ s $])" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"MAccumQ\")(s), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"MAccumQ\")(#text(fill: rgb(\"#5F7A8A\"))[$ s $]), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_test_rs__2470_9_MyTxRead_add_rule__init__80ddaa693754f07d", + "display_name": "init", + "rule_name": "init", + "callee": "MyTxRead::add_rule", + "file": "src/test.rs", + "offset": 83932, + "line": 2470, + "column": 9, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 83932, + "end": 84227 + }, + "pattern_range": { + "start": 84002, + "end": 84095 + }, + "action_range": { + "start": 84109, + "end": 84216 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Unit" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@84139:84161", + "bound_var": null, + "source_text": "ctx.set_fib_read(1, 1)", + "semantic_text": "fib_read(1) = 1", + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 84139, + "end": 84161 + } + }, + { + "id": "effect_1", + "effect_id": "effect@84179:84201", + "bound_var": null, + "source_text": "ctx.set_fib_read(2, 2)", + "semantic_text": "fib_read(2) = 2", + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 84179, + "end": 84201 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "init", + "premises": [ + { + "target_id": "Unit", + "label": "Unit", + "plain_source": "upright(\"Unit\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "effect_0", + "plain_source": "upright(\"fib_read\")(1) = 1", + "colored_source": "upright(\"fib_read\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $]) = #text(fill: rgb(\"#B86A5B\"))[$ 1 $]" + } + }, + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "effect_1", + "plain_source": "upright(\"fib_read\")(2) = 2", + "colored_source": "upright(\"fib_read\")(#text(fill: rgb(\"#B86A5B\"))[$ 2 $]) = #text(fill: rgb(\"#B86A5B\"))[$ 2 $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"Unit\"), upright(\"fib_read\")(1) = 1 \\ upright(\"fib_read\")(2) = 2) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $], upright(\"fib_read\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $]) = #text(fill: rgb(\"#B86A5B\"))[$ 1 $] \\ upright(\"fib_read\")(#text(fill: rgb(\"#B86A5B\"))[$ 2 $]) = #text(fill: rgb(\"#B86A5B\"))[$ 2 $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_test_rs__2485_9_MyTxRead_add_rule__use_query__ea34f0cedf3ddb45", + "display_name": "use_query", + "rule_name": "use_query", + "callee": "MyTxRead::add_rule", + "file": "src/test.rs", + "offset": 84350, + "line": 2485, + "column": 9, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 84350, + "end": 85110 + }, + "pattern_range": { + "start": 84429, + "end": 84921 + }, + "action_range": { + "start": 84935, + "end": 85099 + } + }, + "nodes": [ + { + "id": "v1", + "kind": "query", + "dsl_type": "FibRead", + "label": "v1: FibRead", + "range": { + "start": 84552, + "end": 84581 + }, + "inputs": [ + "x1" + ] + }, + { + "id": "v2", + "kind": "query", + "dsl_type": "FibRead", + "label": "v2: FibRead", + "range": { + "start": 84598, + "end": 84627 + }, + "inputs": [ + "x2" + ] + } + ], + "edges": [ + { + "from": "v1", + "to": "x1", + "kind": "operand", + "index": 0 + }, + { + "from": "v2", + "to": "x2", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "v1", + "v2", + "v1", + "v2" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "x1.handle().eq(&1_i64)", + "resolved_text": "x1.handle().eq(&1_i64)", + "semantic_text": "x1 == 1", + "referenced_vars": [], + "range": { + "start": 84832, + "end": 84854 + } + }, + { + "id": "constraint_1", + "source_text": "x2.handle().eq(&2_i64)", + "resolved_text": "x2.handle().eq(&2_i64)", + "semantic_text": "x2 == 2", + "referenced_vars": [], + "range": { + "start": 84884, + "end": 84906 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@85056:85084", + "bound_var": null, + "source_text": "ctx.set_fib_read(3, v1 + v2)", + "semantic_text": "fib_read(3) = v1 + v2", + "referenced_pat_vars": [ + "v1", + "v2" + ], + "referenced_action_vars": [ + "v1", + "v2" + ], + "range": { + "start": 85056, + "end": 85084 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "use_query", + "premises": [ + { + "target_id": "v1", + "label": "v1: FibRead", + "plain_source": "upright(\"FibRead\")(x_1)", + "colored_source": "upright(\"FibRead\")(#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $])" + }, + { + "target_id": "v2", + "label": "v2: FibRead", + "plain_source": "upright(\"FibRead\")(x_2)", + "colored_source": "upright(\"FibRead\")(#text(fill: rgb(\"#5F7A8A\"))[$ x_2 $])" + }, + { + "target_id": "v1", + "label": "v1: FibRead", + "plain_source": "upright(\"FibRead\")(x_1)", + "colored_source": "upright(\"FibRead\")(#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $])" + }, + { + "target_id": "v2", + "label": "v2: FibRead", + "plain_source": "upright(\"FibRead\")(x_2)", + "colored_source": "upright(\"FibRead\")(#text(fill: rgb(\"#5F7A8A\"))[$ x_2 $])" + } + ], + "side_conditions": [ + "x_1 == 1", + "x_2 == 2" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "effect_0", + "plain_source": "upright(\"fib_read\")(3) = v_1 + v_2", + "colored_source": "upright(\"fib_read\")(#text(fill: rgb(\"#B86A5B\"))[$ 3 $]) = #text(fill: rgb(\"#B86A5B\"))[$ v_1 + v_2 $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"FibRead\")(x_1) \\ upright(\"FibRead\")(x_2) \\ upright(\"FibRead\")(x_1) \\ upright(\"FibRead\")(x_2), upright(\"fib_read\")(3) = v_1 + v_2) quad upright(\"if\") quad x_1 == 1 \\ x_2 == 2", + "colored": "frac(upright(\"FibRead\")(#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) \\ upright(\"FibRead\")(#text(fill: rgb(\"#5F7A8A\"))[$ x_2 $]) \\ upright(\"FibRead\")(#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]) \\ upright(\"FibRead\")(#text(fill: rgb(\"#5F7A8A\"))[$ x_2 $]), upright(\"fib_read\")(#text(fill: rgb(\"#B86A5B\"))[$ 3 $]) = #text(fill: rgb(\"#B86A5B\"))[$ v_1 + v_2 $]) quad upright(\"if\") quad x_1 == 1 \\ x_2 == 2" + } + } + } + }, + { + "id": "src_test_rs__2542_13_MyTxPrim_add_rule__upstream_primitives_egg__5b0f06817300c750", + "display_name": "upstream_primitives_egg", + "rule_name": "upstream_primitives_egg", + "callee": "MyTxPrim::add_rule", + "file": "src/test.rs", + "offset": 86321, + "line": 2542, + "column": 13, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 86321, + "end": 87228 + }, + "pattern_range": { + "start": 86425, + "end": 87180 + }, + "action_range": { + "start": 87198, + "end": 87213 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Unit" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "add_ok", + "resolved_text": "((&2_i64).as_handle() + (&2_i64).as_handle()).eq(&4_i64)", + "semantic_text": "2 + 2 == 4", + "referenced_vars": [], + "range": { + "start": 86995, + "end": 87001 + } + }, + { + "id": "constraint_1", + "source_text": "sub_ok1", + "resolved_text": "((&2_i64).as_handle() - (&1_i64).as_handle()).eq(&1_i64)", + "semantic_text": "2 - 1 == 1", + "referenced_vars": [], + "range": { + "start": 87035, + "end": 87042 + } + }, + { + "id": "constraint_2", + "source_text": "sub_ok2", + "resolved_text": "((&1_i64).as_handle() - (&2_i64).as_handle()).eq(&-1_i64)", + "semantic_text": "1 - 2 == -1", + "referenced_vars": [], + "range": { + "start": 87076, + "end": 87083 + } + }, + { + "id": "constraint_3", + "source_text": "lt_ok", + "resolved_text": "(&1_i64).as_handle().lt(&2_i64)", + "semantic_text": "1 < 2", + "referenced_vars": [], + "range": { + "start": 87117, + "end": 87122 + } + }, + { + "id": "constraint_4", + "source_text": "gt_ok", + "resolved_text": "(&1_i64).as_handle().gt(&-2_i64)", + "semantic_text": "1 > -2", + "referenced_vars": [], + "range": { + "start": 87156, + "end": 87161 + } + } + ], + "action_effects": [], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [ + { + "severity": "warning", + "message": "Pat::new(...) found, but no root variables could be extracted", + "range": { + "start": 86951, + "end": 86962 + } + } + ], + "math_view": { + "rule_name": "upstream_primitives_egg", + "premises": [ + { + "target_id": "Unit", + "label": "Unit", + "plain_source": "upright(\"Unit\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $]" + } + ], + "side_conditions": [ + "2 + 2 == 4", + "2 - 1 == 1", + "1 - 2 == -1", + "1 < 2", + "1 > -2" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"Unit\"), upright(\"no conclusion\")) quad upright(\"if\") quad 2 + 2 == 4 \\ 2 - 1 == 1 \\ 1 - 2 == -1 \\ 1 < 2 \\ 1 > -2", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $], upright(\"no conclusion\")) quad upright(\"if\") quad 2 + 2 == 4 \\ 2 - 1 == 1 \\ 1 - 2 == -1 \\ 1 < 2 \\ 1 > -2" + } + } + } + }, + { + "id": "src_test_rs__2583_13_MyTxI64_add_rule__upstream_i64_to_string_egg__d3dae3047b719dd7", + "display_name": "upstream_i64_to_string_egg", + "rule_name": "upstream_i64_to_string_egg", + "callee": "MyTxI64::add_rule", + "file": "src/test.rs", + "offset": 87824, + "line": 2583, + "column": 13, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 87824, + "end": 88253 + }, + "pattern_range": { + "start": 87930, + "end": 88205 + }, + "action_range": { + "start": 88223, + "end": 88238 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Unit" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "s.eq(&\"20\".to_string())", + "resolved_text": "s.eq(&\"20\".to_string())", + "semantic_text": "s == \"20\".to_string()", + "referenced_vars": [], + "range": { + "start": 88163, + "end": 88186 + } + } + ], + "action_effects": [], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [ + { + "severity": "warning", + "message": "Pat::new(...) found, but no root variables could be extracted", + "range": { + "start": 88144, + "end": 88155 + } + } + ], + "math_view": { + "rule_name": "upstream_i64_to_string_egg", + "premises": [ + { + "target_id": "Unit", + "label": "Unit", + "plain_source": "upright(\"Unit\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $]" + } + ], + "side_conditions": [ + "s == \"20\".upright(\"to_string\")()" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"Unit\"), upright(\"no conclusion\")) quad upright(\"if\") quad s == \"20\".upright(\"to_string\")()", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $], upright(\"no conclusion\")) quad upright(\"if\") quad s == \"20\".upright(\"to_string\")()" + } + } + } + }, + { + "id": "src_test_rs__2614_13_MyTxBool_add_rule__upstream_bool_egg_primitives__c0ca614c88a5b76b", + "display_name": "upstream_bool_egg_primitives", + "rule_name": "upstream_bool_egg_primitives", + "callee": "MyTxBool::add_rule", + "file": "src/test.rs", + "offset": 88858, + "line": 2614, + "column": 13, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 88858, + "end": 94429 + }, + "pattern_range": { + "start": 88967, + "end": 94381 + }, + "action_range": { + "start": 94399, + "end": 94414 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Unit" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "and_tt", + "resolved_text": "prim_call::(\n \"and\",\n vec![(&true).into_handle_ty(), (&true).into_handle_ty()],\n )\n .eq(&true)", + "semantic_text": "prim_call::(\"and\", vec![(&true).into_handle_ty(), (&true).into_handle_ty()]) == true", + "referenced_vars": [], + "range": { + "start": 93605, + "end": 93611 + } + }, + { + "id": "constraint_1", + "source_text": "and_tf", + "resolved_text": "prim_call::(\n \"and\",\n vec![(&true).into_handle_ty(), (&false).into_handle_ty()],\n )\n .eq(&false)", + "semantic_text": "prim_call::(\"and\", vec![(&true).into_handle_ty(), (&false).into_handle_ty()]) == false", + "referenced_vars": [], + "range": { + "start": 93645, + "end": 93651 + } + }, + { + "id": "constraint_2", + "source_text": "or_tf", + "resolved_text": "prim_call::(\n \"or\",\n vec![(&true).into_handle_ty(), (&false).into_handle_ty()],\n )\n .eq(&true)", + "semantic_text": "prim_call::(\"or\", vec![(&true).into_handle_ty(), (&false).into_handle_ty()]) == true", + "referenced_vars": [], + "range": { + "start": 93685, + "end": 93690 + } + }, + { + "id": "constraint_3", + "source_text": "or_tf_ne_false", + "resolved_text": "prim_call::(\n \"or\",\n vec![(&true).into_handle_ty(), (&false).into_handle_ty()],\n )\n .ne(&false)", + "semantic_text": "prim_call::(\"or\", vec![(&true).into_handle_ty(), (&false).into_handle_ty()]) != false", + "referenced_vars": [], + "range": { + "start": 93724, + "end": 93738 + } + }, + { + "id": "constraint_4", + "source_text": "eq_11", + "resolved_text": "prim_call::(\n \"bool-=\",\n vec![(&1_i64).into_handle_ty(), (&1_i64).into_handle_ty()],\n )\n .eq(&true)", + "semantic_text": "prim_call::(\"bool - =\", vec![(&1_i64).into_handle_ty(), (&1_i64).into_handle_ty()]) == true", + "referenced_vars": [], + "range": { + "start": 93772, + "end": 93777 + } + }, + { + "id": "constraint_5", + "source_text": "eq_mm", + "resolved_text": "prim_call::(\n \"bool-=\",\n vec![(&-5_i64).into_handle_ty(), (&-5_i64).into_handle_ty()],\n )\n .eq(&true)", + "semantic_text": "prim_call::(\"bool - =\", vec![(&-5_i64).into_handle_ty(), (&-5_i64).into_handle_ty()]) == true", + "referenced_vars": [], + "range": { + "start": 93811, + "end": 93816 + } + }, + { + "id": "constraint_6", + "source_text": "eq_13", + "resolved_text": "prim_call::(\n \"bool-=\",\n vec![(&1_i64).into_handle_ty(), (&3_i64).into_handle_ty()],\n )\n .eq(&false)", + "semantic_text": "prim_call::(\"bool - =\", vec![(&1_i64).into_handle_ty(), (&3_i64).into_handle_ty()]) == false", + "referenced_vars": [], + "range": { + "start": 93850, + "end": 93855 + } + }, + { + "id": "constraint_7", + "source_text": "eq_31", + "resolved_text": "prim_call::(\n \"bool-=\",\n vec![(&3_i64).into_handle_ty(), (&1_i64).into_handle_ty()],\n )\n .eq(&false)", + "semantic_text": "prim_call::(\"bool - =\", vec![(&3_i64).into_handle_ty(), (&1_i64).into_handle_ty()]) == false", + "referenced_vars": [], + "range": { + "start": 93889, + "end": 93894 + } + }, + { + "id": "constraint_8", + "source_text": "lt_12", + "resolved_text": "prim_call::(\n \"bool-<\",\n vec![(&1_i64).into_handle_ty(), (&2_i64).into_handle_ty()],\n )\n .eq(&true)", + "semantic_text": "prim_call::(\"bool - <\", vec![(&1_i64).into_handle_ty(), (&2_i64).into_handle_ty()]) == true", + "referenced_vars": [], + "range": { + "start": 93928, + "end": 93933 + } + }, + { + "id": "constraint_9", + "source_text": "lt_21", + "resolved_text": "prim_call::(\n \"bool-<\",\n vec![(&2_i64).into_handle_ty(), (&1_i64).into_handle_ty()],\n )\n .eq(&false)", + "semantic_text": "prim_call::(\"bool - <\", vec![(&2_i64).into_handle_ty(), (&1_i64).into_handle_ty()]) == false", + "referenced_vars": [], + "range": { + "start": 93967, + "end": 93972 + } + }, + { + "id": "constraint_10", + "source_text": "lt_11", + "resolved_text": "prim_call::(\n \"bool-<\",\n vec![(&1_i64).into_handle_ty(), (&1_i64).into_handle_ty()],\n )\n .eq(&false)", + "semantic_text": "prim_call::(\"bool - <\", vec![(&1_i64).into_handle_ty(), (&1_i64).into_handle_ty()]) == false", + "referenced_vars": [], + "range": { + "start": 94006, + "end": 94011 + } + }, + { + "id": "constraint_11", + "source_text": "le_12", + "resolved_text": "prim_call::(\n \"bool-<=\",\n vec![(&1_i64).into_handle_ty(), (&2_i64).into_handle_ty()],\n )\n .eq(&true)", + "semantic_text": "prim_call::(\"bool- <= \", vec![(&1_i64).into_handle_ty(), (&2_i64).into_handle_ty()]) == true", + "referenced_vars": [], + "range": { + "start": 94045, + "end": 94050 + } + }, + { + "id": "constraint_12", + "source_text": "le_21", + "resolved_text": "prim_call::(\n \"bool-<=\",\n vec![(&2_i64).into_handle_ty(), (&1_i64).into_handle_ty()],\n )\n .eq(&false)", + "semantic_text": "prim_call::(\"bool- <= \", vec![(&2_i64).into_handle_ty(), (&1_i64).into_handle_ty()]) == false", + "referenced_vars": [], + "range": { + "start": 94084, + "end": 94089 + } + }, + { + "id": "constraint_13", + "source_text": "le_11", + "resolved_text": "prim_call::(\n \"bool-<=\",\n vec![(&1_i64).into_handle_ty(), (&1_i64).into_handle_ty()],\n )\n .eq(&true)", + "semantic_text": "prim_call::(\"bool- <= \", vec![(&1_i64).into_handle_ty(), (&1_i64).into_handle_ty()]) == true", + "referenced_vars": [], + "range": { + "start": 94123, + "end": 94128 + } + }, + { + "id": "constraint_14", + "source_text": "gt_12", + "resolved_text": "prim_call::(\n \"bool->\",\n vec![(&1_i64).into_handle_ty(), (&2_i64).into_handle_ty()],\n )\n .eq(&false)", + "semantic_text": "prim_call::(\"bool - >\", vec![(&1_i64).into_handle_ty(), (&2_i64).into_handle_ty()]) == false", + "referenced_vars": [], + "range": { + "start": 94162, + "end": 94167 + } + }, + { + "id": "constraint_15", + "source_text": "gt_21", + "resolved_text": "prim_call::(\n \"bool->\",\n vec![(&2_i64).into_handle_ty(), (&1_i64).into_handle_ty()],\n )\n .eq(&true)", + "semantic_text": "prim_call::(\"bool - >\", vec![(&2_i64).into_handle_ty(), (&1_i64).into_handle_ty()]) == true", + "referenced_vars": [], + "range": { + "start": 94201, + "end": 94206 + } + }, + { + "id": "constraint_16", + "source_text": "gt_11", + "resolved_text": "prim_call::(\n \"bool->\",\n vec![(&1_i64).into_handle_ty(), (&1_i64).into_handle_ty()],\n )\n .eq(&false)", + "semantic_text": "prim_call::(\"bool - >\", vec![(&1_i64).into_handle_ty(), (&1_i64).into_handle_ty()]) == false", + "referenced_vars": [], + "range": { + "start": 94240, + "end": 94245 + } + }, + { + "id": "constraint_17", + "source_text": "ge_12", + "resolved_text": "prim_call::(\n \"bool->=\",\n vec![(&1_i64).into_handle_ty(), (&2_i64).into_handle_ty()],\n )\n .eq(&false)", + "semantic_text": "prim_call::(\"bool- >= \", vec![(&1_i64).into_handle_ty(), (&2_i64).into_handle_ty()]) == false", + "referenced_vars": [], + "range": { + "start": 94279, + "end": 94284 + } + }, + { + "id": "constraint_18", + "source_text": "ge_21", + "resolved_text": "prim_call::(\n \"bool->=\",\n vec![(&2_i64).into_handle_ty(), (&1_i64).into_handle_ty()],\n )\n .eq(&true)", + "semantic_text": "prim_call::(\"bool- >= \", vec![(&2_i64).into_handle_ty(), (&1_i64).into_handle_ty()]) == true", + "referenced_vars": [], + "range": { + "start": 94318, + "end": 94323 + } + }, + { + "id": "constraint_19", + "source_text": "ge_11", + "resolved_text": "prim_call::(\n \"bool->=\",\n vec![(&1_i64).into_handle_ty(), (&1_i64).into_handle_ty()],\n )\n .eq(&true)", + "semantic_text": "prim_call::(\"bool- >= \", vec![(&1_i64).into_handle_ty(), (&1_i64).into_handle_ty()]) == true", + "referenced_vars": [], + "range": { + "start": 94357, + "end": 94362 + } + } + ], + "action_effects": [], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [ + { + "severity": "warning", + "message": "Pat::new(...) found, but no root variables could be extracted", + "range": { + "start": 93561, + "end": 93572 + } + } + ], + "math_view": { + "rule_name": "upstream_bool_egg_primitives", + "premises": [ + { + "target_id": "Unit", + "label": "Unit", + "plain_source": "upright(\"Unit\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $]" + } + ], + "side_conditions": [ + "upright(\"prim_call\")::(\"upright(\"and\")\", upright(\"vec\")![(&upright(\"true\")).upright(\"into_handle_ty\")(), (&upright(\"true\")).upright(\"into_handle_ty\")()]) == upright(\"true\")", + "upright(\"prim_call\")::(\"upright(\"and\")\", upright(\"vec\")![(&upright(\"true\")).upright(\"into_handle_ty\")(), (&upright(\"false\")).upright(\"into_handle_ty\")()]) == upright(\"false\")", + "upright(\"prim_call\")::(\"upright(\"or\")\", upright(\"vec\")![(&upright(\"true\")).upright(\"into_handle_ty\")(), (&upright(\"false\")).upright(\"into_handle_ty\")()]) == upright(\"true\")", + "upright(\"prim_call\")::(\"upright(\"or\")\", upright(\"vec\")![(&upright(\"true\")).upright(\"into_handle_ty\")(), (&upright(\"false\")).upright(\"into_handle_ty\")()]) != upright(\"false\")", + "upright(\"prim_call\")::(\"upright(\"bool\") - =\", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"true\")", + "upright(\"prim_call\")::(\"upright(\"bool\") - =\", upright(\"vec\")![(&-5upright(\"_i64\")).upright(\"into_handle_ty\")(), (&-5upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"true\")", + "upright(\"prim_call\")::(\"upright(\"bool\") - =\", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&3upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"false\")", + "upright(\"prim_call\")::(\"upright(\"bool\") - =\", upright(\"vec\")![(&3upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"false\")", + "upright(\"prim_call\")::(\"upright(\"bool\") - <\", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&2upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"true\")", + "upright(\"prim_call\")::(\"upright(\"bool\") - <\", upright(\"vec\")![(&2upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"false\")", + "upright(\"prim_call\")::(\"upright(\"bool\") - <\", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"false\")", + "upright(\"prim_call\")::(\"upright(\"bool\")- <= \", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&2upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"true\")", + "upright(\"prim_call\")::(\"upright(\"bool\")- <= \", upright(\"vec\")![(&2upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"false\")", + "upright(\"prim_call\")::(\"upright(\"bool\")- <= \", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"true\")", + "upright(\"prim_call\")::(\"upright(\"bool\") - >\", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&2upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"false\")", + "upright(\"prim_call\")::(\"upright(\"bool\") - >\", upright(\"vec\")![(&2upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"true\")", + "upright(\"prim_call\")::(\"upright(\"bool\") - >\", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"false\")", + "upright(\"prim_call\")::(\"upright(\"bool\")- >= \", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&2upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"false\")", + "upright(\"prim_call\")::(\"upright(\"bool\")- >= \", upright(\"vec\")![(&2upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"true\")", + "upright(\"prim_call\")::(\"upright(\"bool\")- >= \", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"true\")" + ], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"Unit\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"prim_call\")::(\"upright(\"and\")\", upright(\"vec\")![(&upright(\"true\")).upright(\"into_handle_ty\")(), (&upright(\"true\")).upright(\"into_handle_ty\")()]) == upright(\"true\") \\ upright(\"prim_call\")::(\"upright(\"and\")\", upright(\"vec\")![(&upright(\"true\")).upright(\"into_handle_ty\")(), (&upright(\"false\")).upright(\"into_handle_ty\")()]) == upright(\"false\") \\ upright(\"prim_call\")::(\"upright(\"or\")\", upright(\"vec\")![(&upright(\"true\")).upright(\"into_handle_ty\")(), (&upright(\"false\")).upright(\"into_handle_ty\")()]) == upright(\"true\") \\ upright(\"prim_call\")::(\"upright(\"or\")\", upright(\"vec\")![(&upright(\"true\")).upright(\"into_handle_ty\")(), (&upright(\"false\")).upright(\"into_handle_ty\")()]) != upright(\"false\") \\ upright(\"prim_call\")::(\"upright(\"bool\") - =\", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"true\") \\ upright(\"prim_call\")::(\"upright(\"bool\") - =\", upright(\"vec\")![(&-5upright(\"_i64\")).upright(\"into_handle_ty\")(), (&-5upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"true\") \\ upright(\"prim_call\")::(\"upright(\"bool\") - =\", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&3upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"false\") \\ upright(\"prim_call\")::(\"upright(\"bool\") - =\", upright(\"vec\")![(&3upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"false\") \\ upright(\"prim_call\")::(\"upright(\"bool\") - <\", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&2upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"true\") \\ upright(\"prim_call\")::(\"upright(\"bool\") - <\", upright(\"vec\")![(&2upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"false\") \\ upright(\"prim_call\")::(\"upright(\"bool\") - <\", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"false\") \\ upright(\"prim_call\")::(\"upright(\"bool\")- <= \", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&2upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"true\") \\ upright(\"prim_call\")::(\"upright(\"bool\")- <= \", upright(\"vec\")![(&2upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"false\") \\ upright(\"prim_call\")::(\"upright(\"bool\")- <= \", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"true\") \\ upright(\"prim_call\")::(\"upright(\"bool\") - >\", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&2upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"false\") \\ upright(\"prim_call\")::(\"upright(\"bool\") - >\", upright(\"vec\")![(&2upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"true\") \\ upright(\"prim_call\")::(\"upright(\"bool\") - >\", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"false\") \\ upright(\"prim_call\")::(\"upright(\"bool\")- >= \", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&2upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"false\") \\ upright(\"prim_call\")::(\"upright(\"bool\")- >= \", upright(\"vec\")![(&2upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"true\") \\ upright(\"prim_call\")::(\"upright(\"bool\")- >= \", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"true\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"prim_call\")::(\"upright(\"and\")\", upright(\"vec\")![(&upright(\"true\")).upright(\"into_handle_ty\")(), (&upright(\"true\")).upright(\"into_handle_ty\")()]) == upright(\"true\") \\ upright(\"prim_call\")::(\"upright(\"and\")\", upright(\"vec\")![(&upright(\"true\")).upright(\"into_handle_ty\")(), (&upright(\"false\")).upright(\"into_handle_ty\")()]) == upright(\"false\") \\ upright(\"prim_call\")::(\"upright(\"or\")\", upright(\"vec\")![(&upright(\"true\")).upright(\"into_handle_ty\")(), (&upright(\"false\")).upright(\"into_handle_ty\")()]) == upright(\"true\") \\ upright(\"prim_call\")::(\"upright(\"or\")\", upright(\"vec\")![(&upright(\"true\")).upright(\"into_handle_ty\")(), (&upright(\"false\")).upright(\"into_handle_ty\")()]) != upright(\"false\") \\ upright(\"prim_call\")::(\"upright(\"bool\") - =\", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"true\") \\ upright(\"prim_call\")::(\"upright(\"bool\") - =\", upright(\"vec\")![(&-5upright(\"_i64\")).upright(\"into_handle_ty\")(), (&-5upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"true\") \\ upright(\"prim_call\")::(\"upright(\"bool\") - =\", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&3upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"false\") \\ upright(\"prim_call\")::(\"upright(\"bool\") - =\", upright(\"vec\")![(&3upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"false\") \\ upright(\"prim_call\")::(\"upright(\"bool\") - <\", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&2upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"true\") \\ upright(\"prim_call\")::(\"upright(\"bool\") - <\", upright(\"vec\")![(&2upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"false\") \\ upright(\"prim_call\")::(\"upright(\"bool\") - <\", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"false\") \\ upright(\"prim_call\")::(\"upright(\"bool\")- <= \", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&2upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"true\") \\ upright(\"prim_call\")::(\"upright(\"bool\")- <= \", upright(\"vec\")![(&2upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"false\") \\ upright(\"prim_call\")::(\"upright(\"bool\")- <= \", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"true\") \\ upright(\"prim_call\")::(\"upright(\"bool\") - >\", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&2upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"false\") \\ upright(\"prim_call\")::(\"upright(\"bool\") - >\", upright(\"vec\")![(&2upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"true\") \\ upright(\"prim_call\")::(\"upright(\"bool\") - >\", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"false\") \\ upright(\"prim_call\")::(\"upright(\"bool\")- >= \", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&2upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"false\") \\ upright(\"prim_call\")::(\"upright(\"bool\")- >= \", upright(\"vec\")![(&2upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"true\") \\ upright(\"prim_call\")::(\"upright(\"bool\")- >= \", upright(\"vec\")![(&1upright(\"_i64\")).upright(\"into_handle_ty\")(), (&1upright(\"_i64\")).upright(\"into_handle_ty\")()]) == upright(\"true\")" + } + } + } + }, + { + "id": "src_test_rs__2779_13_MyTxTag_add_rule__upstream_bool_tag_rule__4227c6b81e524266", + "display_name": "upstream_bool_tag_rule", + "rule_name": "upstream_bool_tag_rule", + "callee": "MyTxTag::add_rule", + "file": "src/test.rs", + "offset": 95289, + "line": 2779, + "column": 13, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 95289, + "end": 95751 + }, + "pattern_range": { + "start": 95391, + "end": 95586 + }, + "action_range": { + "start": 95604, + "end": 95736 + } + }, + "nodes": [ + { + "id": "r", + "kind": "query", + "dsl_type": "R", + "label": "r: R", + "range": { + "start": 95416, + "end": 95435 + }, + "inputs": [] + } + ], + "edges": [], + "roots": [ + "r" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@95687:95717", + "bound_var": null, + "source_text": "ctx.set_up_bool_tag_f(i, true)", + "semantic_text": "up_bool_tag_f(i) = true", + "referenced_pat_vars": [ + "r" + ], + "referenced_action_vars": [ + "i" + ], + "range": { + "start": 95687, + "end": 95717 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "r0.commit()", + "committed_root": "r0", + "referenced_vars": [ + "r0" + ], + "range": { + "start": 95189, + "end": 95200 + } + } + ], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "upstream_bool_tag_rule", + "premises": [ + { + "target_id": "r", + "label": "r: R", + "plain_source": "r", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ r $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "effect_0", + "plain_source": "upright(\"up_bool_tag_f\")(i) = upright(\"true\")", + "colored_source": "upright(\"up_bool_tag_f\")(#text(fill: rgb(\"#B86A5B\"))[$ i $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"true\") $]" + } + } + ], + "formula_source": { + "plain": "frac(r, upright(\"up_bool_tag_f\")(i) = upright(\"true\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ r $], upright(\"up_bool_tag_f\")(#text(fill: rgb(\"#B86A5B\"))[$ i $]) = #text(fill: rgb(\"#B86A5B\"))[$ upright(\"true\") $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_test_rs__2839_13_MyTxMerge_add_rule__upstream_complex_merge_seed1__5e8bcd90187a2af1", + "display_name": "upstream_complex_merge_seed1", + "rule_name": "upstream_complex_merge_seed1", + "callee": "MyTxMerge::add_rule", + "file": "src/test.rs", + "offset": 97289, + "line": 2839, + "column": 13, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 97289, + "end": 97710 + }, + "pattern_range": { + "start": 97397, + "end": 97502 + }, + "action_range": { + "start": 97520, + "end": 97695 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Unit" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@97562:97576", + "bound_var": "x", + "source_text": "ctx.insert_x()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 97562, + "end": 97576 + } + }, + { + "id": "effect_1", + "effect_id": "effect@97609:97627", + "bound_var": "leaf", + "source_text": "ctx.insert_leaf(x)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "x" + ], + "range": { + "start": 97609, + "end": 97627 + } + }, + { + "id": "effect_2", + "effect_id": "effect@97649:97676", + "bound_var": null, + "source_text": "ctx.set_up_merge_f(0, leaf)", + "semantic_text": "up_merge_f(0) = leaf", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "leaf" + ], + "range": { + "start": 97649, + "end": 97676 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "upstream_complex_merge_seed1", + "premises": [ + { + "target_id": "Unit", + "label": "Unit", + "plain_source": "upright(\"Unit\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_2", + "entry": { + "target_id": "effect:effect_2", + "label": "effect_2", + "plain_source": "upright(\"up_merge_f\")(0) = upright(\"Leaf\")(X())", + "colored_source": "upright(\"up_merge_f\")(#text(fill: rgb(\"#B86A5B\"))[$ 0 $]) = upright(\"Leaf\")(X())" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"Unit\"), upright(\"up_merge_f\")(0) = upright(\"Leaf\")(X())) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $], upright(\"up_merge_f\")(#text(fill: rgb(\"#B86A5B\"))[$ 0 $]) = upright(\"Leaf\")(X())) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_test_rs__2881_13_MyTxMerge_add_rule__upstream_complex_merge_seed2__53a14066ac4a965f", + "display_name": "upstream_complex_merge_seed2", + "rule_name": "upstream_complex_merge_seed2", + "callee": "MyTxMerge::add_rule", + "file": "src/test.rs", + "offset": 98931, + "line": 2881, + "column": 13, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 98931, + "end": 99355 + }, + "pattern_range": { + "start": 99039, + "end": 99144 + }, + "action_range": { + "start": 99162, + "end": 99340 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Unit" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@99204:99218", + "bound_var": "x", + "source_text": "ctx.insert_x()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 99204, + "end": 99218 + } + }, + { + "id": "effect_1", + "effect_id": "effect@99252:99271", + "bound_var": "leaf2", + "source_text": "ctx.insert_leaf2(x)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "x" + ], + "range": { + "start": 99252, + "end": 99271 + } + }, + { + "id": "effect_2", + "effect_id": "effect@99293:99321", + "bound_var": null, + "source_text": "ctx.set_up_merge_f(0, leaf2)", + "semantic_text": "up_merge_f(0) = leaf2", + "referenced_pat_vars": [], + "referenced_action_vars": [ + "leaf2" + ], + "range": { + "start": 99293, + "end": 99321 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "upstream_complex_merge_seed2", + "premises": [ + { + "target_id": "Unit", + "label": "Unit", + "plain_source": "upright(\"Unit\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_2", + "entry": { + "target_id": "effect:effect_2", + "label": "effect_2", + "plain_source": "upright(\"up_merge_f\")(0) = upright(\"Leaf2\")(X())", + "colored_source": "upright(\"up_merge_f\")(#text(fill: rgb(\"#B86A5B\"))[$ 0 $]) = upright(\"Leaf2\")(X())" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"Unit\"), upright(\"up_merge_f\")(0) = upright(\"Leaf2\")(X())) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $], upright(\"up_merge_f\")(#text(fill: rgb(\"#B86A5B\"))[$ 0 $]) = upright(\"Leaf2\")(X())) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_test_rs__2995_13_MyTxDist_add_rule__upstream_merge_during_rebuild_seed__8948afa2cd5de4d4", + "display_name": "upstream_merge_during_rebuild_seed", + "rule_name": "upstream_merge_during_rebuild_seed", + "callee": "MyTxDist::add_rule", + "file": "src/test.rs", + "offset": 103636, + "line": 2995, + "column": 13, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 103636, + "end": 104228 + }, + "pattern_range": { + "start": 103748, + "end": 103853 + }, + "action_range": { + "start": 103871, + "end": 104213 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Unit" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@103910:103974", + "bound_var": null, + "source_text": "ctx.set_up_merge_distance(x_v_seed.clone(), y_v_seed.clone(), 1)", + "semantic_text": "up_merge_distance(x_v_seed, y_v_seed) = 1", + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 103910, + "end": 103974 + } + }, + { + "id": "effect_1", + "effect_id": "effect@103996:104060", + "bound_var": null, + "source_text": "ctx.set_up_merge_distance(a_v_seed.clone(), b_v_seed.clone(), 2)", + "semantic_text": "up_merge_distance(a_v_seed, b_v_seed) = 2", + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 103996, + "end": 104060 + } + }, + { + "id": "effect_2", + "effect_id": "effect@104082:104127", + "bound_var": null, + "source_text": "ctx.union(a_v_seed.clone(), x_v_seed.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 104082, + "end": 104127 + } + }, + { + "id": "effect_3", + "effect_id": "effect@104149:104194", + "bound_var": null, + "source_text": "ctx.union(b_v_seed.clone(), y_v_seed.clone())", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 104149, + "end": 104194 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "a.commit()", + "committed_root": "a", + "referenced_vars": [ + "a" + ], + "range": { + "start": 102942, + "end": 102952 + } + }, + { + "id": "seed_1", + "source_text": "b.commit()", + "committed_root": "b", + "referenced_vars": [ + "b" + ], + "range": { + "start": 102966, + "end": 102976 + } + }, + { + "id": "seed_2", + "source_text": "x.commit()", + "committed_root": "x", + "referenced_vars": [ + "x" + ], + "range": { + "start": 102990, + "end": 103000 + } + }, + { + "id": "seed_3", + "source_text": "y.commit()", + "committed_root": "y", + "referenced_vars": [ + "y" + ], + "range": { + "start": 103014, + "end": 103024 + } + } + ], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "upstream_merge_during_rebuild_seed", + "premises": [ + { + "target_id": "Unit", + "label": "Unit", + "plain_source": "upright(\"Unit\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "effect_0", + "plain_source": "upright(\"up_merge_distance\")(upright(\"x_v_seed\"), upright(\"y_v_seed\")) = 1", + "colored_source": "upright(\"up_merge_distance\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"x_v_seed\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"y_v_seed\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ 1 $]" + } + }, + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "effect_1", + "plain_source": "upright(\"up_merge_distance\")(upright(\"a_v_seed\"), upright(\"b_v_seed\")) = 2", + "colored_source": "upright(\"up_merge_distance\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"a_v_seed\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"b_v_seed\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ 2 $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"Unit\"), upright(\"up_merge_distance\")(upright(\"x_v_seed\"), upright(\"y_v_seed\")) = 1 \\ upright(\"up_merge_distance\")(upright(\"a_v_seed\"), upright(\"b_v_seed\")) = 2) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $], upright(\"up_merge_distance\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"x_v_seed\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"y_v_seed\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ 1 $] \\ upright(\"up_merge_distance\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"a_v_seed\") $], #text(fill: rgb(\"#B86A5B\"))[$ upright(\"b_v_seed\") $]) = #text(fill: rgb(\"#B86A5B\"))[$ 2 $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_test_rs__3058_13_MyTxSat_add_rule__upstream_merge_saturates_seed0__2dfe1f7f22280678", + "display_name": "upstream_merge_saturates_seed0", + "rule_name": "upstream_merge_saturates_seed0", + "callee": "MyTxSat::add_rule", + "file": "src/test.rs", + "offset": 106455, + "line": 3058, + "column": 13, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 106455, + "end": 106786 + }, + "pattern_range": { + "start": 106562, + "end": 106667 + }, + "action_range": { + "start": 106685, + "end": 106771 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Unit" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@106719:106752", + "bound_var": null, + "source_text": "ctx.set_up_merge_saturates_foo(0)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 106719, + "end": 106752 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "upstream_merge_saturates_seed0", + "premises": [ + { + "target_id": "Unit", + "label": "Unit", + "plain_source": "upright(\"Unit\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"Unit\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_test_rs__3072_13_MyTxSat_add_rule__upstream_merge_saturates_egg__871389b3762c39fa", + "display_name": "upstream_merge_saturates_egg", + "rule_name": "upstream_merge_saturates_egg", + "callee": "MyTxSat::add_rule", + "file": "src/test.rs", + "offset": 106938, + "line": 3072, + "column": 13, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 106938, + "end": 107474 + }, + "pattern_range": { + "start": 107046, + "end": 107264 + }, + "action_range": { + "start": 107282, + "end": 107459 + } + }, + "nodes": [ + { + "id": "f", + "kind": "query", + "dsl_type": "up_merge_saturates_foo", + "label": "f: up_merge_saturates_foo", + "range": { + "start": 107071, + "end": 107111 + }, + "inputs": [] + } + ], + "edges": [], + "roots": [ + "f" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@107407:107440", + "bound_var": null, + "source_text": "ctx.set_up_merge_saturates_foo(1)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 107407, + "end": 107440 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "upstream_merge_saturates_egg", + "premises": [ + { + "target_id": "f", + "label": "f: up_merge_saturates_foo", + "plain_source": "f", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ f $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(f, upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ f $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_test_rs__3265_13_MyTxVecRb_add_rule__upstream_vec_rebuild_seed_union__cdbdcfdca2089c91", + "display_name": "upstream_vec_rebuild_seed_union", + "rule_name": "upstream_vec_rebuild_seed_union", + "callee": "MyTxVecRb::add_rule", + "file": "src/test.rs", + "offset": 113524, + "line": 3265, + "column": 13, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 113524, + "end": 113928 + }, + "pattern_range": { + "start": 113634, + "end": 113739 + }, + "action_range": { + "start": 113757, + "end": 113913 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Unit" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@113799:113813", + "bound_var": "a", + "source_text": "ctx.insert_a()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 113799, + "end": 113813 + } + }, + { + "id": "effect_1", + "effect_id": "effect@113843:113857", + "bound_var": "b", + "source_text": "ctx.insert_b()", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 113843, + "end": 113857 + } + }, + { + "id": "effect_2", + "effect_id": "effect@113879:113894", + "bound_var": null, + "source_text": "ctx.union(a, b)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "a", + "b" + ], + "range": { + "start": 113879, + "end": 113894 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "upstream_vec_rebuild_seed_union", + "premises": [ + { + "target_id": "Unit", + "label": "Unit", + "plain_source": "upright(\"Unit\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"Unit\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_test_rs__3495_13_MyTxFib_add_rule__seed__5a686181e434aa12", + "display_name": "seed", + "rule_name": "seed", + "callee": "MyTxFib::add_rule", + "file": "src/test.rs", + "offset": 121384, + "line": 3495, + "column": 13, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 121384, + "end": 121712 + }, + "pattern_range": { + "start": 121465, + "end": 121570 + }, + "action_range": { + "start": 121588, + "end": 121697 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Unit" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@121622:121639", + "bound_var": null, + "source_text": "ctx.set_fib(0, 0)", + "semantic_text": "fib(0) = 0", + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 121622, + "end": 121639 + } + }, + { + "id": "effect_1", + "effect_id": "effect@121661:121678", + "bound_var": null, + "source_text": "ctx.set_fib(1, 1)", + "semantic_text": "fib(1) = 1", + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 121661, + "end": 121678 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "seed", + "premises": [ + { + "target_id": "Unit", + "label": "Unit", + "plain_source": "upright(\"Unit\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "effect_0", + "plain_source": "upright(\"fib\")(0) = 0", + "colored_source": "upright(\"fib\")(#text(fill: rgb(\"#B86A5B\"))[$ 0 $]) = #text(fill: rgb(\"#B86A5B\"))[$ 0 $]" + } + }, + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "effect_1", + "plain_source": "upright(\"fib\")(1) = 1", + "colored_source": "upright(\"fib\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $]) = #text(fill: rgb(\"#B86A5B\"))[$ 1 $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"Unit\"), upright(\"fib\")(0) = 0 \\ upright(\"fib\")(1) = 1) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $], upright(\"fib\")(#text(fill: rgb(\"#B86A5B\"))[$ 0 $]) = #text(fill: rgb(\"#B86A5B\"))[$ 0 $] \\ upright(\"fib\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $]) = #text(fill: rgb(\"#B86A5B\"))[$ 1 $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_test_rs__3510_13_MyTxFib_add_rule__step__a01024a096738825", + "display_name": "step", + "rule_name": "step", + "callee": "MyTxFib::add_rule", + "file": "src/test.rs", + "offset": 121837, + "line": 3510, + "column": 13, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 121837, + "end": 122086 + }, + "pattern_range": { + "start": 121869, + "end": 121877 + }, + "action_range": { + "start": 121879, + "end": 122085 + } + }, + "nodes": [ + { + "id": "f0", + "kind": "query", + "dsl_type": "fib", + "label": "f0: fib", + "range": { + "start": 121062, + "end": 121086 + }, + "inputs": [ + "x" + ] + }, + { + "id": "f1", + "kind": "query", + "dsl_type": "fib", + "label": "f1: fib", + "range": { + "start": 121099, + "end": 121124 + }, + "inputs": [ + "x1" + ] + } + ], + "edges": [ + { + "from": "f0", + "to": "x", + "kind": "operand", + "index": 0 + }, + { + "from": "f1", + "to": "x1", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "x2", + "f0", + "f1" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@122046:122070", + "bound_var": null, + "source_text": "ctx.set_fib(x2, f0 + f1)", + "semantic_text": "fib(x2) = f0 + f1", + "referenced_pat_vars": [ + "f0", + "f1", + "x2" + ], + "referenced_action_vars": [ + "f0", + "f1", + "x2" + ], + "range": { + "start": 122046, + "end": 122070 + } + } + ], + "seed_facts": [], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "step", + "premises": [ + { + "target_id": "f0", + "label": "f0: fib", + "plain_source": "upright(\"fib\")(x)", + "colored_source": "upright(\"fib\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $])" + }, + { + "target_id": "f1", + "label": "f1: fib", + "plain_source": "upright(\"fib\")(x_1)", + "colored_source": "upright(\"fib\")(#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $])" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "effect_0", + "plain_source": "upright(\"fib\")(x_2) = f_0 + f_1", + "colored_source": "upright(\"fib\")(#text(fill: rgb(\"#5F7A8A\"))[$ x_2 $]) = #text(fill: rgb(\"#B86A5B\"))[$ f_0 + f_1 $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"fib\")(x) \\ upright(\"fib\")(x_1), upright(\"fib\")(x_2) = f_0 + f_1) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"fib\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) \\ upright(\"fib\")(#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]), upright(\"fib\")(#text(fill: rgb(\"#5F7A8A\"))[$ x_2 $]) = #text(fill: rgb(\"#B86A5B\"))[$ f_0 + f_1 $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_test_rs__3533_9_SampleTx_add_rule_with_hook__sample_trace_rule__e5294ad576e0e23a", + "display_name": "sample_trace_rule", + "rule_name": "sample_trace_rule", + "callee": "SampleTx::add_rule_with_hook", + "file": "src/test.rs", + "offset": 122670, + "line": 3533, + "column": 9, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 122670, + "end": 123017 + }, + "pattern_range": { + "start": 122766, + "end": 122776 + }, + "action_range": { + "start": 122790, + "end": 122974 + } + }, + "nodes": [ + { + "id": "expr", + "kind": "query_leaf", + "dsl_type": "SampleExpr", + "label": "expr: SampleExpr", + "range": { + "start": 81383, + "end": 81419 + }, + "inputs": [] + }, + { + "id": "_root", + "kind": "query", + "dsl_type": "TraceRoot", + "label": "_root: TraceRoot", + "range": { + "start": 81428, + "end": 81464 + }, + "inputs": [ + "expr" + ] + } + ], + "edges": [ + { + "from": "_root", + "to": "expr", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "expr" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@122829:122854", + "bound_var": "one", + "source_text": "ctx.insert_trace_const(1)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 122829, + "end": 122854 + } + }, + { + "id": "effect_1", + "effect_id": "effect@122882:122917", + "bound_var": "sum", + "source_text": "ctx.insert_trace_add(pat.expr, one)", + "semantic_text": null, + "referenced_pat_vars": [ + "expr" + ], + "referenced_action_vars": [ + "one" + ], + "range": { + "start": 122882, + "end": 122917 + } + }, + { + "id": "effect_2", + "effect_id": "effect@122935:122959", + "bound_var": null, + "source_text": "ctx.union(pat.expr, sum)", + "semantic_text": null, + "referenced_pat_vars": [ + "expr" + ], + "referenced_action_vars": [ + "sum" + ], + "range": { + "start": 122935, + "end": 122959 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "root.commit()", + "committed_root": "root", + "referenced_vars": [ + "root" + ], + "range": { + "start": 122484, + "end": 122497 + } + } + ], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "sample_trace_rule", + "premises": [ + { + "target_id": "expr", + "label": "expr: SampleExpr", + "plain_source": "upright(\"expr\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "one", + "plain_source": "upright(\"TraceConst\")(1)", + "colored_source": "upright(\"TraceConst\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $])" + }, + { + "target_id": "effect:effect_1", + "label": "sum", + "plain_source": "upright(\"TraceAdd\")(upright(\"expr\"), upright(\"TraceConst\")(1))", + "colored_source": "upright(\"TraceAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $], upright(\"TraceConst\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $]))" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "expr", + "label": "expr: SampleExpr", + "plain_source": "upright(\"expr\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $]" + }, + "to": { + "target_id": "effect:effect_1", + "label": "sum", + "plain_source": "upright(\"TraceAdd\")(upright(\"expr\"), upright(\"TraceConst\")(1))", + "colored_source": "upright(\"TraceAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $], upright(\"TraceConst\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $]))" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"expr\"), upright(\"expr\") arrow.r.double upright(\"TraceAdd\")(upright(\"expr\"), upright(\"TraceConst\")(1))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $] arrow.r.double upright(\"TraceAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $], upright(\"TraceConst\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $]))) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_test_rs__3585_9_SampleTx_add_rule_with_hook__sample_trace_event_ids__a0f0af92a65e457c", + "display_name": "sample_trace_event_ids", + "rule_name": "sample_trace_event_ids", + "callee": "SampleTx::add_rule_with_hook", + "file": "src/test.rs", + "offset": 124312, + "line": 3585, + "column": 9, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 124312, + "end": 124664 + }, + "pattern_range": { + "start": 124413, + "end": 124423 + }, + "action_range": { + "start": 124437, + "end": 124621 + } + }, + "nodes": [ + { + "id": "expr", + "kind": "query_leaf", + "dsl_type": "SampleExpr", + "label": "expr: SampleExpr", + "range": { + "start": 81383, + "end": 81419 + }, + "inputs": [] + }, + { + "id": "_root", + "kind": "query", + "dsl_type": "TraceRoot", + "label": "_root: TraceRoot", + "range": { + "start": 81428, + "end": 81464 + }, + "inputs": [ + "expr" + ] + } + ], + "edges": [ + { + "from": "_root", + "to": "expr", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "expr" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@124476:124501", + "bound_var": "one", + "source_text": "ctx.insert_trace_const(1)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 124476, + "end": 124501 + } + }, + { + "id": "effect_1", + "effect_id": "effect@124529:124564", + "bound_var": "sum", + "source_text": "ctx.insert_trace_add(pat.expr, one)", + "semantic_text": null, + "referenced_pat_vars": [ + "expr" + ], + "referenced_action_vars": [ + "one" + ], + "range": { + "start": 124529, + "end": 124564 + } + }, + { + "id": "effect_2", + "effect_id": "effect@124582:124606", + "bound_var": null, + "source_text": "ctx.union(pat.expr, sum)", + "semantic_text": null, + "referenced_pat_vars": [ + "expr" + ], + "referenced_action_vars": [ + "sum" + ], + "range": { + "start": 124582, + "end": 124606 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "root.commit()", + "committed_root": "root", + "referenced_vars": [ + "root" + ], + "range": { + "start": 124122, + "end": 124135 + } + } + ], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "sample_trace_event_ids", + "premises": [ + { + "target_id": "expr", + "label": "expr: SampleExpr", + "plain_source": "upright(\"expr\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $]" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "one", + "plain_source": "upright(\"TraceConst\")(1)", + "colored_source": "upright(\"TraceConst\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $])" + }, + { + "target_id": "effect:effect_1", + "label": "sum", + "plain_source": "upright(\"TraceAdd\")(upright(\"expr\"), upright(\"TraceConst\")(1))", + "colored_source": "upright(\"TraceAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $], upright(\"TraceConst\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $]))" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "expr", + "label": "expr: SampleExpr", + "plain_source": "upright(\"expr\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $]" + }, + "to": { + "target_id": "effect:effect_1", + "label": "sum", + "plain_source": "upright(\"TraceAdd\")(upright(\"expr\"), upright(\"TraceConst\")(1))", + "colored_source": "upright(\"TraceAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $], upright(\"TraceConst\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $]))" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"expr\"), upright(\"expr\") arrow.r.double upright(\"TraceAdd\")(upright(\"expr\"), upright(\"TraceConst\")(1))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $] arrow.r.double upright(\"TraceAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"expr\") $], upright(\"TraceConst\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $]))) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "src_test_rs__3674_9_MyTxProof_add_rule__MulPat__a5cea44a446f9209", + "display_name": "MulPat", + "rule_name": "MulPat", + "callee": "MyTxProof::add_rule", + "file": "src/test.rs", + "offset": 127038, + "line": 3674, + "column": 9, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 127038, + "end": 127698 + }, + "pattern_range": { + "start": 127114, + "end": 127468 + }, + "action_range": { + "start": 127482, + "end": 127687 + } + }, + "nodes": [ + { + "id": "l", + "kind": "query", + "dsl_type": "ProofConst", + "label": "l: ProofConst", + "range": { + "start": 127135, + "end": 127163 + }, + "inputs": [] + }, + { + "id": "r", + "kind": "query", + "dsl_type": "ProofConst", + "label": "r: ProofConst", + "range": { + "start": 127180, + "end": 127208 + }, + "inputs": [] + }, + { + "id": "p", + "kind": "query", + "dsl_type": "ProofMul", + "label": "p: ProofMul", + "range": { + "start": 127225, + "end": 127257 + }, + "inputs": [ + "l", + "r" + ] + } + ], + "edges": [ + { + "from": "p", + "to": "l", + "kind": "operand", + "index": 0 + }, + { + "from": "p", + "to": "r", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "l", + "r", + "p" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@127601:127628", + "bound_var": "op_value", + "source_text": "ctx.insert_proof_const(cal)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 127601, + "end": 127628 + } + }, + { + "id": "effect_1", + "effect_id": "effect@127646:127672", + "bound_var": null, + "source_text": "ctx.union(pat.p, op_value)", + "semantic_text": null, + "referenced_pat_vars": [ + "p" + ], + "referenced_action_vars": [ + "op_value" + ], + "range": { + "start": 127646, + "end": 127672 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "mul.commit()", + "committed_root": "mul", + "referenced_vars": [ + "mul" + ], + "range": { + "start": 126726, + "end": 126738 + } + }, + { + "id": "seed_1", + "source_text": "expected.commit()", + "committed_root": "expected", + "referenced_vars": [ + "expected" + ], + "range": { + "start": 126880, + "end": 126897 + } + } + ], + "display_templates": [ + { + "variant_name": "MDiff", + "template": "{x} + {f}", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integ {f} {x}", + "fields": [ + "f", + "x" + ] + } + ], + "typst_templates": [ + { + "variant_name": "MDiff", + "template": "diff({x}, {f})", + "fields": [ + "x", + "f" + ] + }, + { + "variant_name": "MIntegral", + "template": "integral({f}, {x})", + "fields": [ + "f", + "x" + ] + }, + { + "variant_name": "Var", + "template": "{name}", + "fields": [ + "name" + ] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": [ + "lhs", + "rhs" + ] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": [ + "lhs", + "rhs" + ] + } + ], + "precedence_templates": [ + { + "variant_name": "MDiff", + "precedence": 5 + }, + { + "variant_name": "Add", + "precedence": 10 + }, + { + "variant_name": "Mul", + "precedence": 20 + } + ], + "diagnostics": [], + "math_view": { + "rule_name": "MulPat", + "premises": [ + { + "target_id": "l", + "label": "l: ProofConst", + "plain_source": "l", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ l $]" + }, + { + "target_id": "r", + "label": "r: ProofConst", + "plain_source": "r", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ r $]" + }, + { + "target_id": "p", + "label": "p: ProofMul", + "plain_source": "upright(\"ProofMul\")(l, r)", + "colored_source": "upright(\"ProofMul\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "op_value", + "plain_source": "upright(\"ProofConst\")(upright(\"cal\"))", + "colored_source": "upright(\"ProofConst\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"cal\") $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "p", + "label": "p: ProofMul", + "plain_source": "upright(\"ProofMul\")(l, r)", + "colored_source": "upright(\"ProofMul\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "op_value", + "plain_source": "upright(\"ProofConst\")(upright(\"cal\"))", + "colored_source": "upright(\"ProofConst\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"cal\") $])" + } + } + ], + "formula_source": { + "plain": "frac(l \\ r \\ upright(\"ProofMul\")(l, r), upright(\"ProofMul\")(l, r) arrow.r.double upright(\"ProofConst\")(upright(\"cal\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ l $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ r $] \\ upright(\"ProofMul\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $]), upright(\"ProofMul\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $]) arrow.r.double upright(\"ProofConst\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"cal\") $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "tests_eboost_heuristic_extract_rs__61_5_EBoostDemoTx_add_rule__union_wrapper_variants_for_eboost_test__a3ab8dfbf4fb0e22", + "display_name": "union_wrapper_variants_for_eboost_test", + "rule_name": "union_wrapper_variants_for_eboost_test", + "callee": "EBoostDemoTx::add_rule", + "file": "tests/eboost_heuristic_extract.rs", + "offset": 1227, + "line": 61, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 1227, + "end": 1727 + }, + "pattern_range": { + "start": 1326, + "end": 1639 + }, + "action_range": { + "start": 1649, + "end": 1720 + } + }, + "nodes": [ + { + "id": "leaf", + "kind": "query", + "dsl_type": "Leaf", + "label": "leaf: Leaf", + "range": { + "start": 1343, + "end": 1368 + }, + "inputs": [] + }, + { + "id": "cheap", + "kind": "query", + "dsl_type": "CheapWrap", + "label": "cheap: CheapWrap", + "range": { + "start": 1381, + "end": 1417 + }, + "inputs": [ + "leaf" + ] + }, + { + "id": "expensive", + "kind": "query", + "dsl_type": "ExpensiveWrap", + "label": "expensive: ExpensiveWrap", + "range": { + "start": 1430, + "end": 1474 + }, + "inputs": [ + "leaf" + ] + } + ], + "edges": [ + { + "from": "cheap", + "to": "leaf", + "kind": "operand", + "index": 0 + }, + { + "from": "expensive", + "to": "leaf", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "cheap", + "expensive" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@1674:1709", + "bound_var": null, + "source_text": "ctx.union(pat.cheap, pat.expensive)", + "semantic_text": null, + "referenced_pat_vars": [ + "cheap", + "expensive" + ], + "referenced_action_vars": [], + "range": { + "start": 1674, + "end": 1709 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "cheap.commit()", + "committed_root": "cheap", + "referenced_vars": [ + "cheap" + ], + "range": { + "start": 1032, + "end": 1046 + } + }, + { + "id": "seed_1", + "source_text": "expensive.commit()", + "committed_root": "expensive", + "referenced_vars": [ + "expensive" + ], + "range": { + "start": 1115, + "end": 1133 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "union_wrapper_variants_for_eboost_test", + "premises": [ + { + "target_id": "cheap", + "label": "cheap: CheapWrap", + "plain_source": "upright(\"CheapWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"CheapWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + }, + { + "target_id": "expensive", + "label": "expensive: ExpensiveWrap", + "plain_source": "upright(\"ExpensiveWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"ExpensiveWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_0", + "from": { + "target_id": "cheap", + "label": "cheap: CheapWrap", + "plain_source": "upright(\"CheapWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"CheapWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + }, + "to": { + "target_id": "expensive", + "label": "expensive: ExpensiveWrap", + "plain_source": "upright(\"ExpensiveWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"ExpensiveWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"CheapWrap\")(upright(\"leaf\")) \\ upright(\"ExpensiveWrap\")(upright(\"leaf\")), upright(\"CheapWrap\")(upright(\"leaf\")) arrow.r.double upright(\"ExpensiveWrap\")(upright(\"leaf\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"CheapWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]) \\ upright(\"ExpensiveWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]), upright(\"CheapWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]) arrow.r.double upright(\"ExpensiveWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "tests_eboost_heuristic_extract_rs__118_5_EBoostCseTx_add_rule__union_common_subexpr_roots_for_eboost_test__6ce9c1fae979ee5e", + "display_name": "union_common_subexpr_roots_for_eboost_test", + "rule_name": "union_common_subexpr_roots_for_eboost_test", + "callee": "EBoostCseTx::add_rule", + "file": "tests/eboost_heuristic_extract.rs", + "offset": 3424, + "line": 118, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 3424, + "end": 4615 + }, + "pattern_range": { + "start": 3526, + "end": 4264 + }, + "action_range": { + "start": 4274, + "end": 4608 + } + }, + "nodes": [ + { + "id": "shared_leaf", + "kind": "query", + "dsl_type": "CLeaf", + "label": "shared_leaf: CLeaf", + "range": { + "start": 3543, + "end": 3576 + }, + "inputs": [] + }, + { + "id": "shared_l1", + "kind": "query", + "dsl_type": "CInc", + "label": "shared_l1: CInc", + "range": { + "start": 3589, + "end": 3631 + }, + "inputs": [ + "shared_leaf" + ] + }, + { + "id": "shared", + "kind": "query", + "dsl_type": "CInc", + "label": "shared: CInc", + "range": { + "start": 3644, + "end": 3681 + }, + "inputs": [ + "shared_l1" + ] + }, + { + "id": "shared_root", + "kind": "query", + "dsl_type": "CPair", + "label": "shared_root: CPair", + "range": { + "start": 3694, + "end": 3743 + }, + "inputs": [ + "shared", + "shared" + ] + }, + { + "id": "left_leaf", + "kind": "query", + "dsl_type": "CLeaf", + "label": "left_leaf: CLeaf", + "range": { + "start": 3757, + "end": 3788 + }, + "inputs": [] + }, + { + "id": "left", + "kind": "query", + "dsl_type": "CInc", + "label": "left: CInc", + "range": { + "start": 3801, + "end": 3836 + }, + "inputs": [ + "left_leaf" + ] + }, + { + "id": "right_leaf", + "kind": "query", + "dsl_type": "CLeaf", + "label": "right_leaf: CLeaf", + "range": { + "start": 3849, + "end": 3881 + }, + "inputs": [] + }, + { + "id": "right", + "kind": "query", + "dsl_type": "CInc", + "label": "right: CInc", + "range": { + "start": 3894, + "end": 3931 + }, + "inputs": [ + "right_leaf" + ] + }, + { + "id": "duplicated_root", + "kind": "query", + "dsl_type": "CPair", + "label": "duplicated_root: CPair", + "range": { + "start": 3944, + "end": 3994 + }, + "inputs": [ + "left", + "right" + ] + } + ], + "edges": [ + { + "from": "shared_l1", + "to": "shared_leaf", + "kind": "operand", + "index": 0 + }, + { + "from": "shared", + "to": "shared_l1", + "kind": "operand", + "index": 0 + }, + { + "from": "shared_root", + "to": "shared", + "kind": "operand", + "index": 0 + }, + { + "from": "shared_root", + "to": "shared", + "kind": "operand", + "index": 1 + }, + { + "from": "left", + "to": "left_leaf", + "kind": "operand", + "index": 0 + }, + { + "from": "right", + "to": "right_leaf", + "kind": "operand", + "index": 0 + }, + { + "from": "duplicated_root", + "to": "left", + "kind": "operand", + "index": 0 + }, + { + "from": "duplicated_root", + "to": "right", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "shared_leaf", + "shared_root", + "left_leaf", + "right_leaf", + "duplicated_root" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@4536:4583", + "bound_var": null, + "source_text": "ctx.union(pat.shared_root, pat.duplicated_root)", + "semantic_text": null, + "referenced_pat_vars": [ + "duplicated_root", + "shared_root" + ], + "referenced_action_vars": [], + "range": { + "start": 4536, + "end": 4583 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "shared_root.commit()", + "committed_root": "shared_root", + "referenced_vars": [ + "shared_root" + ], + "range": { + "start": 2999, + "end": 3019 + } + }, + { + "id": "seed_1", + "source_text": "duplicated_root.commit()", + "committed_root": "duplicated_root", + "referenced_vars": [ + "duplicated_root" + ], + "range": { + "start": 3303, + "end": 3327 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "union_common_subexpr_roots_for_eboost_test", + "premises": [ + { + "target_id": "shared_leaf", + "label": "shared_leaf: CLeaf", + "plain_source": "upright(\"shared_leaf\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared_leaf\") $]" + }, + { + "target_id": "shared_root", + "label": "shared_root: CPair", + "plain_source": "upright(\"CPair\")(upright(\"shared\"), upright(\"shared\"))", + "colored_source": "upright(\"CPair\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $])" + }, + { + "target_id": "left_leaf", + "label": "left_leaf: CLeaf", + "plain_source": "upright(\"left_leaf\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left_leaf\") $]" + }, + { + "target_id": "right_leaf", + "label": "right_leaf: CLeaf", + "plain_source": "upright(\"right_leaf\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right_leaf\") $]" + }, + { + "target_id": "duplicated_root", + "label": "duplicated_root: CPair", + "plain_source": "upright(\"CPair\")(upright(\"CInc\")(upright(\"left_leaf\")), upright(\"CInc\")(upright(\"right_leaf\")))", + "colored_source": "upright(\"CPair\")(upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left_leaf\") $]), upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right_leaf\") $]))" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_0", + "from": { + "target_id": "shared_root", + "label": "shared_root: CPair", + "plain_source": "upright(\"CPair\")(upright(\"shared\"), upright(\"shared\"))", + "colored_source": "upright(\"CPair\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $])" + }, + "to": { + "target_id": "duplicated_root", + "label": "duplicated_root: CPair", + "plain_source": "upright(\"CPair\")(upright(\"CInc\")(upright(\"left_leaf\")), upright(\"CInc\")(upright(\"right_leaf\")))", + "colored_source": "upright(\"CPair\")(upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left_leaf\") $]), upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right_leaf\") $]))" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"shared_leaf\") \\ upright(\"CPair\")(upright(\"shared\"), upright(\"shared\")) \\ upright(\"left_leaf\") \\ upright(\"right_leaf\") \\ upright(\"CPair\")(upright(\"CInc\")(upright(\"left_leaf\")), upright(\"CInc\")(upright(\"right_leaf\"))), upright(\"CPair\")(upright(\"shared\"), upright(\"shared\")) arrow.r.double upright(\"CPair\")(upright(\"CInc\")(upright(\"left_leaf\")), upright(\"CInc\")(upright(\"right_leaf\")))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared_leaf\") $] \\ upright(\"CPair\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left_leaf\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right_leaf\") $] \\ upright(\"CPair\")(upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left_leaf\") $]), upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right_leaf\") $])), upright(\"CPair\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $]) arrow.r.double upright(\"CPair\")(upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left_leaf\") $]), upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right_leaf\") $]))) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "tests_eboost_heuristic_extract_rs__187_5_EBoostCycleTx_add_rule__union_cyclic_root_variants_for_eboost_test__77381b84a862500d", + "display_name": "union_cyclic_root_variants_for_eboost_test", + "rule_name": "union_cyclic_root_variants_for_eboost_test", + "callee": "EBoostCycleTx::add_rule", + "file": "tests/eboost_heuristic_extract.rs", + "offset": 6119, + "line": 187, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 6119, + "end": 6555 + }, + "pattern_range": { + "start": 6223, + "end": 6473 + }, + "action_range": { + "start": 6483, + "end": 6548 + } + }, + "nodes": [ + { + "id": "leaf", + "kind": "query", + "dsl_type": "CycleLeaf", + "label": "leaf: CycleLeaf", + "range": { + "start": 6240, + "end": 6270 + }, + "inputs": [] + }, + { + "id": "wrap", + "kind": "query", + "dsl_type": "CycleWrap", + "label": "wrap: CycleWrap", + "range": { + "start": 6283, + "end": 6318 + }, + "inputs": [ + "leaf" + ] + } + ], + "edges": [ + { + "from": "wrap", + "to": "leaf", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "leaf", + "wrap" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@6508:6537", + "bound_var": null, + "source_text": "ctx.union(pat.leaf, pat.wrap)", + "semantic_text": null, + "referenced_pat_vars": [ + "leaf", + "wrap" + ], + "referenced_action_vars": [], + "range": { + "start": 6508, + "end": 6537 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "wrap.commit()", + "committed_root": "wrap", + "referenced_vars": [ + "wrap" + ], + "range": { + "start": 6007, + "end": 6020 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "union_cyclic_root_variants_for_eboost_test", + "premises": [ + { + "target_id": "leaf", + "label": "leaf: CycleLeaf", + "plain_source": "upright(\"leaf\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]" + }, + { + "target_id": "wrap", + "label": "wrap: CycleWrap", + "plain_source": "upright(\"CycleWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"CycleWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_0", + "from": { + "target_id": "leaf", + "label": "leaf: CycleLeaf", + "plain_source": "upright(\"leaf\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]" + }, + "to": { + "target_id": "wrap", + "label": "wrap: CycleWrap", + "plain_source": "upright(\"CycleWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"CycleWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"leaf\") \\ upright(\"CycleWrap\")(upright(\"leaf\")), upright(\"leaf\") arrow.r.double upright(\"CycleWrap\")(upright(\"leaf\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $] \\ upright(\"CycleWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $] arrow.r.double upright(\"CycleWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "tests_eboost_layered_extract_rs__50_5_LayeredDemoTx_add_rule__union_wrapper_variants_for_layered_test__9f1740289e2f97ba", + "display_name": "union_wrapper_variants_for_layered_test", + "rule_name": "union_wrapper_variants_for_layered_test", + "callee": "LayeredDemoTx::add_rule", + "file": "tests/eboost_layered_extract.rs", + "offset": 1081, + "line": 50, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 1081, + "end": 1583 + }, + "pattern_range": { + "start": 1182, + "end": 1495 + }, + "action_range": { + "start": 1505, + "end": 1576 + } + }, + "nodes": [ + { + "id": "leaf", + "kind": "query", + "dsl_type": "Leaf", + "label": "leaf: Leaf", + "range": { + "start": 1199, + "end": 1224 + }, + "inputs": [] + }, + { + "id": "cheap", + "kind": "query", + "dsl_type": "CheapWrap", + "label": "cheap: CheapWrap", + "range": { + "start": 1237, + "end": 1273 + }, + "inputs": [ + "leaf" + ] + }, + { + "id": "expensive", + "kind": "query", + "dsl_type": "ExpensiveWrap", + "label": "expensive: ExpensiveWrap", + "range": { + "start": 1286, + "end": 1330 + }, + "inputs": [ + "leaf" + ] + } + ], + "edges": [ + { + "from": "cheap", + "to": "leaf", + "kind": "operand", + "index": 0 + }, + { + "from": "expensive", + "to": "leaf", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "cheap", + "expensive" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@1530:1565", + "bound_var": null, + "source_text": "ctx.union(pat.cheap, pat.expensive)", + "semantic_text": null, + "referenced_pat_vars": [ + "cheap", + "expensive" + ], + "referenced_action_vars": [], + "range": { + "start": 1530, + "end": 1565 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "cheap.commit()", + "committed_root": "cheap", + "referenced_vars": [ + "cheap" + ], + "range": { + "start": 883, + "end": 897 + } + }, + { + "id": "seed_1", + "source_text": "expensive.commit()", + "committed_root": "expensive", + "referenced_vars": [ + "expensive" + ], + "range": { + "start": 967, + "end": 985 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "union_wrapper_variants_for_layered_test", + "premises": [ + { + "target_id": "cheap", + "label": "cheap: CheapWrap", + "plain_source": "upright(\"CheapWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"CheapWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + }, + { + "target_id": "expensive", + "label": "expensive: ExpensiveWrap", + "plain_source": "upright(\"ExpensiveWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"ExpensiveWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_0", + "from": { + "target_id": "cheap", + "label": "cheap: CheapWrap", + "plain_source": "upright(\"CheapWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"CheapWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + }, + "to": { + "target_id": "expensive", + "label": "expensive: ExpensiveWrap", + "plain_source": "upright(\"ExpensiveWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"ExpensiveWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"CheapWrap\")(upright(\"leaf\")) \\ upright(\"ExpensiveWrap\")(upright(\"leaf\")), upright(\"CheapWrap\")(upright(\"leaf\")) arrow.r.double upright(\"ExpensiveWrap\")(upright(\"leaf\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"CheapWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]) \\ upright(\"ExpensiveWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]), upright(\"CheapWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]) arrow.r.double upright(\"ExpensiveWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "tests_eboost_layered_extract_rs__107_5_LayeredCseTx_add_rule__union_common_subexpr_roots_for_layered_test__48677df7494e3f68", + "display_name": "union_common_subexpr_roots_for_layered_test", + "rule_name": "union_common_subexpr_roots_for_layered_test", + "callee": "LayeredCseTx::add_rule", + "file": "tests/eboost_layered_extract.rs", + "offset": 3154, + "line": 107, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 3154, + "end": 4347 + }, + "pattern_range": { + "start": 3258, + "end": 3996 + }, + "action_range": { + "start": 4006, + "end": 4340 + } + }, + "nodes": [ + { + "id": "shared_leaf", + "kind": "query", + "dsl_type": "CLeaf", + "label": "shared_leaf: CLeaf", + "range": { + "start": 3275, + "end": 3308 + }, + "inputs": [] + }, + { + "id": "shared_l1", + "kind": "query", + "dsl_type": "CInc", + "label": "shared_l1: CInc", + "range": { + "start": 3321, + "end": 3363 + }, + "inputs": [ + "shared_leaf" + ] + }, + { + "id": "shared", + "kind": "query", + "dsl_type": "CInc", + "label": "shared: CInc", + "range": { + "start": 3376, + "end": 3413 + }, + "inputs": [ + "shared_l1" + ] + }, + { + "id": "shared_root", + "kind": "query", + "dsl_type": "CPair", + "label": "shared_root: CPair", + "range": { + "start": 3426, + "end": 3475 + }, + "inputs": [ + "shared", + "shared" + ] + }, + { + "id": "left_leaf", + "kind": "query", + "dsl_type": "CLeaf", + "label": "left_leaf: CLeaf", + "range": { + "start": 3489, + "end": 3520 + }, + "inputs": [] + }, + { + "id": "left", + "kind": "query", + "dsl_type": "CInc", + "label": "left: CInc", + "range": { + "start": 3533, + "end": 3568 + }, + "inputs": [ + "left_leaf" + ] + }, + { + "id": "right_leaf", + "kind": "query", + "dsl_type": "CLeaf", + "label": "right_leaf: CLeaf", + "range": { + "start": 3581, + "end": 3613 + }, + "inputs": [] + }, + { + "id": "right", + "kind": "query", + "dsl_type": "CInc", + "label": "right: CInc", + "range": { + "start": 3626, + "end": 3663 + }, + "inputs": [ + "right_leaf" + ] + }, + { + "id": "duplicated_root", + "kind": "query", + "dsl_type": "CPair", + "label": "duplicated_root: CPair", + "range": { + "start": 3676, + "end": 3726 + }, + "inputs": [ + "left", + "right" + ] + } + ], + "edges": [ + { + "from": "shared_l1", + "to": "shared_leaf", + "kind": "operand", + "index": 0 + }, + { + "from": "shared", + "to": "shared_l1", + "kind": "operand", + "index": 0 + }, + { + "from": "shared_root", + "to": "shared", + "kind": "operand", + "index": 0 + }, + { + "from": "shared_root", + "to": "shared", + "kind": "operand", + "index": 1 + }, + { + "from": "left", + "to": "left_leaf", + "kind": "operand", + "index": 0 + }, + { + "from": "right", + "to": "right_leaf", + "kind": "operand", + "index": 0 + }, + { + "from": "duplicated_root", + "to": "left", + "kind": "operand", + "index": 0 + }, + { + "from": "duplicated_root", + "to": "right", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "shared_leaf", + "shared_root", + "left_leaf", + "right_leaf", + "duplicated_root" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@4268:4315", + "bound_var": null, + "source_text": "ctx.union(pat.shared_root, pat.duplicated_root)", + "semantic_text": null, + "referenced_pat_vars": [ + "duplicated_root", + "shared_root" + ], + "referenced_action_vars": [], + "range": { + "start": 4268, + "end": 4315 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "shared_root.commit()", + "committed_root": "shared_root", + "referenced_vars": [ + "shared_root" + ], + "range": { + "start": 2722, + "end": 2742 + } + }, + { + "id": "seed_1", + "source_text": "duplicated_root.commit()", + "committed_root": "duplicated_root", + "referenced_vars": [ + "duplicated_root" + ], + "range": { + "start": 3031, + "end": 3055 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "union_common_subexpr_roots_for_layered_test", + "premises": [ + { + "target_id": "shared_leaf", + "label": "shared_leaf: CLeaf", + "plain_source": "upright(\"shared_leaf\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared_leaf\") $]" + }, + { + "target_id": "shared_root", + "label": "shared_root: CPair", + "plain_source": "upright(\"CPair\")(upright(\"shared\"), upright(\"shared\"))", + "colored_source": "upright(\"CPair\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $])" + }, + { + "target_id": "left_leaf", + "label": "left_leaf: CLeaf", + "plain_source": "upright(\"left_leaf\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left_leaf\") $]" + }, + { + "target_id": "right_leaf", + "label": "right_leaf: CLeaf", + "plain_source": "upright(\"right_leaf\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right_leaf\") $]" + }, + { + "target_id": "duplicated_root", + "label": "duplicated_root: CPair", + "plain_source": "upright(\"CPair\")(upright(\"CInc\")(upright(\"left_leaf\")), upright(\"CInc\")(upright(\"right_leaf\")))", + "colored_source": "upright(\"CPair\")(upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left_leaf\") $]), upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right_leaf\") $]))" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_0", + "from": { + "target_id": "shared_root", + "label": "shared_root: CPair", + "plain_source": "upright(\"CPair\")(upright(\"shared\"), upright(\"shared\"))", + "colored_source": "upright(\"CPair\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $])" + }, + "to": { + "target_id": "duplicated_root", + "label": "duplicated_root: CPair", + "plain_source": "upright(\"CPair\")(upright(\"CInc\")(upright(\"left_leaf\")), upright(\"CInc\")(upright(\"right_leaf\")))", + "colored_source": "upright(\"CPair\")(upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left_leaf\") $]), upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right_leaf\") $]))" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"shared_leaf\") \\ upright(\"CPair\")(upright(\"shared\"), upright(\"shared\")) \\ upright(\"left_leaf\") \\ upright(\"right_leaf\") \\ upright(\"CPair\")(upright(\"CInc\")(upright(\"left_leaf\")), upright(\"CInc\")(upright(\"right_leaf\"))), upright(\"CPair\")(upright(\"shared\"), upright(\"shared\")) arrow.r.double upright(\"CPair\")(upright(\"CInc\")(upright(\"left_leaf\")), upright(\"CInc\")(upright(\"right_leaf\")))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared_leaf\") $] \\ upright(\"CPair\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left_leaf\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right_leaf\") $] \\ upright(\"CPair\")(upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left_leaf\") $]), upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right_leaf\") $])), upright(\"CPair\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $]) arrow.r.double upright(\"CPair\")(upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left_leaf\") $]), upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right_leaf\") $]))) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "tests_indexed_pat_decode_rs__47_5_MyTxIndexedDecode_add_rule__indexed_pat_decode_fold__2dec5f4909593a57", + "display_name": "indexed_pat_decode_fold", + "rule_name": "indexed_pat_decode_fold", + "callee": "MyTxIndexedDecode::add_rule", + "file": "tests/indexed_pat_decode.rs", + "offset": 1263, + "line": 47, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 1263, + "end": 1973 + }, + "pattern_range": { + "start": 1352, + "end": 1733 + }, + "action_range": { + "start": 1743, + "end": 1966 + } + }, + "nodes": [ + { + "id": "lhs", + "kind": "query", + "dsl_type": "IxConst", + "label": "lhs: IxConst", + "range": { + "start": 1369, + "end": 1396 + }, + "inputs": [] + }, + { + "id": "rhs", + "kind": "query", + "dsl_type": "IxConst", + "label": "rhs: IxConst", + "range": { + "start": 1409, + "end": 1436 + }, + "inputs": [] + }, + { + "id": "add", + "kind": "query", + "dsl_type": "IxAdd", + "label": "add: IxAdd", + "range": { + "start": 1449, + "end": 1484 + }, + "inputs": [ + "lhs", + "rhs" + ] + }, + { + "id": "root", + "kind": "query", + "dsl_type": "IxNeg", + "label": "root: IxNeg", + "range": { + "start": 1497, + "end": 1527 + }, + "inputs": [ + "add" + ] + } + ], + "edges": [ + { + "from": "add", + "to": "lhs", + "kind": "operand", + "index": 0 + }, + { + "from": "add", + "to": "rhs", + "kind": "operand", + "index": 1 + }, + { + "from": "root", + "to": "add", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "lhs", + "rhs", + "add", + "root" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@1781:1854", + "bound_var": "folded", + "source_text": "ctx.insert_ix_const(ctx.devalue(pat.lhs.n) * 10 + ctx.devalue(pat.rhs.n))", + "semantic_text": null, + "referenced_pat_vars": [ + "lhs", + "rhs" + ], + "referenced_action_vars": [], + "range": { + "start": 1781, + "end": 1854 + } + }, + { + "id": "effect_1", + "effect_id": "effect@1885:1910", + "bound_var": "folded_neg", + "source_text": "ctx.insert_ix_neg(folded)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [ + "folded" + ], + "range": { + "start": 1885, + "end": 1910 + } + }, + { + "id": "effect_2", + "effect_id": "effect@1924:1955", + "bound_var": null, + "source_text": "ctx.union(pat.root, folded_neg)", + "semantic_text": null, + "referenced_pat_vars": [ + "root" + ], + "referenced_action_vars": [ + "folded_neg" + ], + "range": { + "start": 1924, + "end": 1955 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "root.commit()", + "committed_root": "root", + "referenced_vars": [ + "root" + ], + "range": { + "start": 1112, + "end": 1125 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "indexed_pat_decode_fold", + "premises": [ + { + "target_id": "lhs", + "label": "lhs: IxConst", + "plain_source": "upright(\"lhs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]" + }, + { + "target_id": "rhs", + "label": "rhs: IxConst", + "plain_source": "upright(\"rhs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $]" + }, + { + "target_id": "add", + "label": "add: IxAdd", + "plain_source": "upright(\"IxAdd\")(upright(\"lhs\"), upright(\"rhs\"))", + "colored_source": "upright(\"IxAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $])" + }, + { + "target_id": "root", + "label": "root: IxNeg", + "plain_source": "upright(\"IxNeg\")(upright(\"IxAdd\")(upright(\"lhs\"), upright(\"rhs\")))", + "colored_source": "upright(\"IxNeg\")(upright(\"IxAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $]))" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "folded", + "plain_source": "upright(\"IxConst\")(upright(\"lhs.n\") * 10 + upright(\"rhs.n\"))", + "colored_source": "upright(\"IxConst\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lhs.n\") * 10 + upright(\"rhs.n\") $])" + }, + { + "target_id": "effect:effect_1", + "label": "folded_neg", + "plain_source": "upright(\"IxNeg\")(upright(\"IxConst\")(upright(\"lhs.n\") * 10 + upright(\"rhs.n\")))", + "colored_source": "upright(\"IxNeg\")(upright(\"IxConst\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lhs.n\") * 10 + upright(\"rhs.n\") $]))" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_2", + "from": { + "target_id": "root", + "label": "root: IxNeg", + "plain_source": "upright(\"IxNeg\")(upright(\"IxAdd\")(upright(\"lhs\"), upright(\"rhs\")))", + "colored_source": "upright(\"IxNeg\")(upright(\"IxAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $]))" + }, + "to": { + "target_id": "effect:effect_1", + "label": "folded_neg", + "plain_source": "upright(\"IxNeg\")(upright(\"IxConst\")(upright(\"lhs.n\") * 10 + upright(\"rhs.n\")))", + "colored_source": "upright(\"IxNeg\")(upright(\"IxConst\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lhs.n\") * 10 + upright(\"rhs.n\") $]))" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"lhs\") \\ upright(\"rhs\") \\ upright(\"IxAdd\")(upright(\"lhs\"), upright(\"rhs\")) \\ upright(\"IxNeg\")(upright(\"IxAdd\")(upright(\"lhs\"), upright(\"rhs\"))), upright(\"IxNeg\")(upright(\"IxAdd\")(upright(\"lhs\"), upright(\"rhs\"))) arrow.r.double upright(\"IxNeg\")(upright(\"IxConst\")(upright(\"lhs.n\") * 10 + upright(\"rhs.n\")))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $] \\ upright(\"IxAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $]) \\ upright(\"IxNeg\")(upright(\"IxAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $])), upright(\"IxNeg\")(upright(\"IxAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $])) arrow.r.double upright(\"IxNeg\")(upright(\"IxConst\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"lhs.n\") * 10 + upright(\"rhs.n\") $]))) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "tests_rustsat_common_subexpr_rs__33_5_RustsatCseTx_add_rule__union_common_subexpr_roots_for_rustsat_test__33fc8424ddd5b2ff", + "display_name": "union_common_subexpr_roots_for_rustsat_test", + "rule_name": "union_common_subexpr_roots_for_rustsat_test", + "callee": "RustsatCseTx::add_rule", + "file": "tests/rustsat_common_subexpr.rs", + "offset": 1113, + "line": 33, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 1113, + "end": 2306 + }, + "pattern_range": { + "start": 1217, + "end": 1955 + }, + "action_range": { + "start": 1965, + "end": 2299 + } + }, + "nodes": [ + { + "id": "shared_leaf", + "kind": "query", + "dsl_type": "CLeaf", + "label": "shared_leaf: CLeaf", + "range": { + "start": 1234, + "end": 1267 + }, + "inputs": [] + }, + { + "id": "shared_l1", + "kind": "query", + "dsl_type": "CInc", + "label": "shared_l1: CInc", + "range": { + "start": 1280, + "end": 1322 + }, + "inputs": [ + "shared_leaf" + ] + }, + { + "id": "shared", + "kind": "query", + "dsl_type": "CInc", + "label": "shared: CInc", + "range": { + "start": 1335, + "end": 1372 + }, + "inputs": [ + "shared_l1" + ] + }, + { + "id": "shared_root", + "kind": "query", + "dsl_type": "CPair", + "label": "shared_root: CPair", + "range": { + "start": 1385, + "end": 1434 + }, + "inputs": [ + "shared", + "shared" + ] + }, + { + "id": "left_leaf", + "kind": "query", + "dsl_type": "CLeaf", + "label": "left_leaf: CLeaf", + "range": { + "start": 1448, + "end": 1479 + }, + "inputs": [] + }, + { + "id": "left", + "kind": "query", + "dsl_type": "CInc", + "label": "left: CInc", + "range": { + "start": 1492, + "end": 1527 + }, + "inputs": [ + "left_leaf" + ] + }, + { + "id": "right_leaf", + "kind": "query", + "dsl_type": "CLeaf", + "label": "right_leaf: CLeaf", + "range": { + "start": 1540, + "end": 1572 + }, + "inputs": [] + }, + { + "id": "right", + "kind": "query", + "dsl_type": "CInc", + "label": "right: CInc", + "range": { + "start": 1585, + "end": 1622 + }, + "inputs": [ + "right_leaf" + ] + }, + { + "id": "duplicated_root", + "kind": "query", + "dsl_type": "CPair", + "label": "duplicated_root: CPair", + "range": { + "start": 1635, + "end": 1685 + }, + "inputs": [ + "left", + "right" + ] + } + ], + "edges": [ + { + "from": "shared_l1", + "to": "shared_leaf", + "kind": "operand", + "index": 0 + }, + { + "from": "shared", + "to": "shared_l1", + "kind": "operand", + "index": 0 + }, + { + "from": "shared_root", + "to": "shared", + "kind": "operand", + "index": 0 + }, + { + "from": "shared_root", + "to": "shared", + "kind": "operand", + "index": 1 + }, + { + "from": "left", + "to": "left_leaf", + "kind": "operand", + "index": 0 + }, + { + "from": "right", + "to": "right_leaf", + "kind": "operand", + "index": 0 + }, + { + "from": "duplicated_root", + "to": "left", + "kind": "operand", + "index": 0 + }, + { + "from": "duplicated_root", + "to": "right", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "shared_leaf", + "shared_root", + "left_leaf", + "right_leaf", + "duplicated_root" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@2227:2274", + "bound_var": null, + "source_text": "ctx.union(pat.shared_root, pat.duplicated_root)", + "semantic_text": null, + "referenced_pat_vars": [ + "duplicated_root", + "shared_root" + ], + "referenced_action_vars": [], + "range": { + "start": 2227, + "end": 2274 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "shared_root.commit()", + "committed_root": "shared_root", + "referenced_vars": [ + "shared_root" + ], + "range": { + "start": 681, + "end": 701 + } + }, + { + "id": "seed_1", + "source_text": "duplicated_root.commit()", + "committed_root": "duplicated_root", + "referenced_vars": [ + "duplicated_root" + ], + "range": { + "start": 990, + "end": 1014 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "union_common_subexpr_roots_for_rustsat_test", + "premises": [ + { + "target_id": "shared_leaf", + "label": "shared_leaf: CLeaf", + "plain_source": "upright(\"shared_leaf\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared_leaf\") $]" + }, + { + "target_id": "shared_root", + "label": "shared_root: CPair", + "plain_source": "upright(\"CPair\")(upright(\"shared\"), upright(\"shared\"))", + "colored_source": "upright(\"CPair\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $])" + }, + { + "target_id": "left_leaf", + "label": "left_leaf: CLeaf", + "plain_source": "upright(\"left_leaf\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left_leaf\") $]" + }, + { + "target_id": "right_leaf", + "label": "right_leaf: CLeaf", + "plain_source": "upright(\"right_leaf\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right_leaf\") $]" + }, + { + "target_id": "duplicated_root", + "label": "duplicated_root: CPair", + "plain_source": "upright(\"CPair\")(upright(\"CInc\")(upright(\"left_leaf\")), upright(\"CInc\")(upright(\"right_leaf\")))", + "colored_source": "upright(\"CPair\")(upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left_leaf\") $]), upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right_leaf\") $]))" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_0", + "from": { + "target_id": "shared_root", + "label": "shared_root: CPair", + "plain_source": "upright(\"CPair\")(upright(\"shared\"), upright(\"shared\"))", + "colored_source": "upright(\"CPair\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $])" + }, + "to": { + "target_id": "duplicated_root", + "label": "duplicated_root: CPair", + "plain_source": "upright(\"CPair\")(upright(\"CInc\")(upright(\"left_leaf\")), upright(\"CInc\")(upright(\"right_leaf\")))", + "colored_source": "upright(\"CPair\")(upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left_leaf\") $]), upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right_leaf\") $]))" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"shared_leaf\") \\ upright(\"CPair\")(upright(\"shared\"), upright(\"shared\")) \\ upright(\"left_leaf\") \\ upright(\"right_leaf\") \\ upright(\"CPair\")(upright(\"CInc\")(upright(\"left_leaf\")), upright(\"CInc\")(upright(\"right_leaf\"))), upright(\"CPair\")(upright(\"shared\"), upright(\"shared\")) arrow.r.double upright(\"CPair\")(upright(\"CInc\")(upright(\"left_leaf\")), upright(\"CInc\")(upright(\"right_leaf\")))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared_leaf\") $] \\ upright(\"CPair\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $]) \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left_leaf\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right_leaf\") $] \\ upright(\"CPair\")(upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left_leaf\") $]), upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right_leaf\") $])), upright(\"CPair\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"shared\") $]) arrow.r.double upright(\"CPair\")(upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"left_leaf\") $]), upright(\"CInc\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"right_leaf\") $]))) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "tests_rustsat_optimize_expression_rs__47_5_RustsatDemoTx_add_rule__union_wrapper_variants_for_rustsat_test__6023a1276b59ebd0", + "display_name": "union_wrapper_variants_for_rustsat_test", + "rule_name": "union_wrapper_variants_for_rustsat_test", + "callee": "RustsatDemoTx::add_rule", + "file": "tests/rustsat_optimize_expression.rs", + "offset": 1031, + "line": 47, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 1031, + "end": 1533 + }, + "pattern_range": { + "start": 1132, + "end": 1445 + }, + "action_range": { + "start": 1455, + "end": 1526 + } + }, + "nodes": [ + { + "id": "leaf", + "kind": "query", + "dsl_type": "Leaf", + "label": "leaf: Leaf", + "range": { + "start": 1149, + "end": 1174 + }, + "inputs": [] + }, + { + "id": "cheap", + "kind": "query", + "dsl_type": "CheapWrap", + "label": "cheap: CheapWrap", + "range": { + "start": 1187, + "end": 1223 + }, + "inputs": [ + "leaf" + ] + }, + { + "id": "expensive", + "kind": "query", + "dsl_type": "ExpensiveWrap", + "label": "expensive: ExpensiveWrap", + "range": { + "start": 1236, + "end": 1280 + }, + "inputs": [ + "leaf" + ] + } + ], + "edges": [ + { + "from": "cheap", + "to": "leaf", + "kind": "operand", + "index": 0 + }, + { + "from": "expensive", + "to": "leaf", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "cheap", + "expensive" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@1480:1515", + "bound_var": null, + "source_text": "ctx.union(pat.cheap, pat.expensive)", + "semantic_text": null, + "referenced_pat_vars": [ + "cheap", + "expensive" + ], + "referenced_action_vars": [], + "range": { + "start": 1480, + "end": 1515 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "cheap.commit()", + "committed_root": "cheap", + "referenced_vars": [ + "cheap" + ], + "range": { + "start": 833, + "end": 847 + } + }, + { + "id": "seed_1", + "source_text": "expensive.commit()", + "committed_root": "expensive", + "referenced_vars": [ + "expensive" + ], + "range": { + "start": 917, + "end": 935 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "union_wrapper_variants_for_rustsat_test", + "premises": [ + { + "target_id": "cheap", + "label": "cheap: CheapWrap", + "plain_source": "upright(\"CheapWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"CheapWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + }, + { + "target_id": "expensive", + "label": "expensive: ExpensiveWrap", + "plain_source": "upright(\"ExpensiveWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"ExpensiveWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_0", + "from": { + "target_id": "cheap", + "label": "cheap: CheapWrap", + "plain_source": "upright(\"CheapWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"CheapWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + }, + "to": { + "target_id": "expensive", + "label": "expensive: ExpensiveWrap", + "plain_source": "upright(\"ExpensiveWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"ExpensiveWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"CheapWrap\")(upright(\"leaf\")) \\ upright(\"ExpensiveWrap\")(upright(\"leaf\")), upright(\"CheapWrap\")(upright(\"leaf\")) arrow.r.double upright(\"ExpensiveWrap\")(upright(\"leaf\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"CheapWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]) \\ upright(\"ExpensiveWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]), upright(\"CheapWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]) arrow.r.double upright(\"ExpensiveWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "tests_rustsat_optimize_expression_rs__97_5_RustsatCycleTx_add_rule__union_cyclic_root_variants_for_rustsat_test__95e6eb955bcbc94f", + "display_name": "union_cyclic_root_variants_for_rustsat_test", + "rule_name": "union_cyclic_root_variants_for_rustsat_test", + "callee": "RustsatCycleTx::add_rule", + "file": "tests/rustsat_optimize_expression.rs", + "offset": 2827, + "line": 97, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 2827, + "end": 3265 + }, + "pattern_range": { + "start": 2933, + "end": 3183 + }, + "action_range": { + "start": 3193, + "end": 3258 + } + }, + "nodes": [ + { + "id": "leaf", + "kind": "query", + "dsl_type": "CycleLeaf", + "label": "leaf: CycleLeaf", + "range": { + "start": 2950, + "end": 2980 + }, + "inputs": [] + }, + { + "id": "wrap", + "kind": "query", + "dsl_type": "CycleWrap", + "label": "wrap: CycleWrap", + "range": { + "start": 2993, + "end": 3028 + }, + "inputs": [ + "leaf" + ] + } + ], + "edges": [ + { + "from": "wrap", + "to": "leaf", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "leaf", + "wrap" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@3218:3247", + "bound_var": null, + "source_text": "ctx.union(pat.leaf, pat.wrap)", + "semantic_text": null, + "referenced_pat_vars": [ + "leaf", + "wrap" + ], + "referenced_action_vars": [], + "range": { + "start": 3218, + "end": 3247 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "wrap.commit()", + "committed_root": "wrap", + "referenced_vars": [ + "wrap" + ], + "range": { + "start": 2713, + "end": 2726 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "union_cyclic_root_variants_for_rustsat_test", + "premises": [ + { + "target_id": "leaf", + "label": "leaf: CycleLeaf", + "plain_source": "upright(\"leaf\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]" + }, + { + "target_id": "wrap", + "label": "wrap: CycleWrap", + "plain_source": "upright(\"CycleWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"CycleWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_0", + "from": { + "target_id": "leaf", + "label": "leaf: CycleLeaf", + "plain_source": "upright(\"leaf\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]" + }, + "to": { + "target_id": "wrap", + "label": "wrap: CycleWrap", + "plain_source": "upright(\"CycleWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"CycleWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"leaf\") \\ upright(\"CycleWrap\")(upright(\"leaf\")), upright(\"leaf\") arrow.r.double upright(\"CycleWrap\")(upright(\"leaf\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $] \\ upright(\"CycleWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]), #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $] arrow.r.double upright(\"CycleWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "tests_schedule_builder_rs__24_5_ScheduleBuilderTx_add_rule__schedule_builder_seed__948d6a935e637071", + "display_name": "schedule_builder_seed", + "rule_name": "schedule_builder_seed", + "callee": "ScheduleBuilderTx::add_rule", + "file": "tests/schedule_builder.rs", + "offset": 465, + "line": 24, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 465, + "end": 744 + }, + "pattern_range": { + "start": 549, + "end": 630 + }, + "action_range": { + "start": 640, + "end": 737 + } + }, + "nodes": [], + "edges": [], + "roots": [ + "Unit" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@666:689", + "bound_var": null, + "source_text": "ctx.set_sched_fib(0, 0)", + "semantic_text": "sched_fib(0) = 0", + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 666, + "end": 689 + } + }, + { + "id": "effect_1", + "effect_id": "effect@703:726", + "bound_var": null, + "source_text": "ctx.set_sched_fib(1, 1)", + "semantic_text": "sched_fib(1) = 1", + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 703, + "end": 726 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "schedule_builder_seed", + "premises": [ + { + "target_id": "Unit", + "label": "Unit", + "plain_source": "upright(\"Unit\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "effect_0", + "plain_source": "upright(\"sched_fib\")(0) = 0", + "colored_source": "upright(\"sched_fib\")(#text(fill: rgb(\"#B86A5B\"))[$ 0 $]) = #text(fill: rgb(\"#B86A5B\"))[$ 0 $]" + } + }, + { + "kind": "derive", + "id": "effect_1", + "entry": { + "target_id": "effect:effect_1", + "label": "effect_1", + "plain_source": "upright(\"sched_fib\")(1) = 1", + "colored_source": "upright(\"sched_fib\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $]) = #text(fill: rgb(\"#B86A5B\"))[$ 1 $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"Unit\"), upright(\"sched_fib\")(0) = 0 \\ upright(\"sched_fib\")(1) = 1) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"Unit\") $], upright(\"sched_fib\")(#text(fill: rgb(\"#B86A5B\"))[$ 0 $]) = #text(fill: rgb(\"#B86A5B\"))[$ 0 $] \\ upright(\"sched_fib\")(#text(fill: rgb(\"#B86A5B\"))[$ 1 $]) = #text(fill: rgb(\"#B86A5B\"))[$ 1 $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "tests_schedule_builder_rs__38_5_ScheduleBuilderTx_add_rule__schedule_builder_step__ff12c6450e789dcf", + "display_name": "schedule_builder_step", + "rule_name": "schedule_builder_step", + "callee": "ScheduleBuilderTx::add_rule", + "file": "tests/schedule_builder.rs", + "offset": 823, + "line": 38, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 823, + "end": 1678 + }, + "pattern_range": { + "start": 907, + "end": 1469 + }, + "action_range": { + "start": 1479, + "end": 1671 + } + }, + "nodes": [ + { + "id": "f0", + "kind": "query", + "dsl_type": "sched_fib", + "label": "f0: sched_fib", + "range": { + "start": 1263, + "end": 1293 + }, + "inputs": [ + "x" + ] + }, + { + "id": "f1", + "kind": "query", + "dsl_type": "sched_fib", + "label": "f1: sched_fib", + "range": { + "start": 1306, + "end": 1337 + }, + "inputs": [ + "x1" + ] + } + ], + "edges": [ + { + "from": "f0", + "to": "x", + "kind": "operand", + "index": 0 + }, + { + "from": "f1", + "to": "x1", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "x", + "x1", + "x2", + "f0", + "f1" + ], + "constraints": [ + { + "id": "constraint_0", + "source_text": "x1_constraint", + "resolved_text": "x1.handle().eq(&(x.handle() + (&1_i64).as_handle()))", + "semantic_text": "x1 == x + 1", + "referenced_vars": [ + "x", + "x1" + ], + "range": { + "start": 1406, + "end": 1419 + } + }, + { + "id": "constraint_1", + "source_text": "x2_constraint", + "resolved_text": "x2.handle().eq(&(x.handle() + (&2_i64).as_handle()))", + "semantic_text": "x2 == x + 2", + "referenced_vars": [ + "x", + "x2" + ], + "range": { + "start": 1445, + "end": 1458 + } + } + ], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@1630:1660", + "bound_var": null, + "source_text": "ctx.set_sched_fib(x2, f0 + f1)", + "semantic_text": "sched_fib(x2) = f0 + f1", + "referenced_pat_vars": [ + "f0", + "f1", + "x2" + ], + "referenced_action_vars": [ + "f0", + "f1", + "x2" + ], + "range": { + "start": 1630, + "end": 1660 + } + } + ], + "seed_facts": [], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "schedule_builder_step", + "premises": [ + { + "target_id": "f0", + "label": "f0: sched_fib", + "plain_source": "upright(\"sched_fib\")(x)", + "colored_source": "upright(\"sched_fib\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $])" + }, + { + "target_id": "f1", + "label": "f1: sched_fib", + "plain_source": "upright(\"sched_fib\")(x_1)", + "colored_source": "upright(\"sched_fib\")(#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $])" + } + ], + "side_conditions": [ + "x_1 == x + 1", + "x_2 == x + 2" + ], + "derivations": [], + "conclusions": [ + { + "kind": "derive", + "id": "effect_0", + "entry": { + "target_id": "effect:effect_0", + "label": "effect_0", + "plain_source": "upright(\"sched_fib\")(x_2) = f_0 + f_1", + "colored_source": "upright(\"sched_fib\")(#text(fill: rgb(\"#5F7A8A\"))[$ x_2 $]) = #text(fill: rgb(\"#B86A5B\"))[$ f_0 + f_1 $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"sched_fib\")(x) \\ upright(\"sched_fib\")(x_1), upright(\"sched_fib\")(x_2) = f_0 + f_1) quad upright(\"if\") quad x_1 == x + 1 \\ x_2 == x + 2", + "colored": "frac(upright(\"sched_fib\")(#text(fill: rgb(\"#5F7A8A\"))[$ x $]) \\ upright(\"sched_fib\")(#text(fill: rgb(\"#5F7A8A\"))[$ x_1 $]), upright(\"sched_fib\")(#text(fill: rgb(\"#5F7A8A\"))[$ x_2 $]) = #text(fill: rgb(\"#B86A5B\"))[$ f_0 + f_1 $]) quad upright(\"if\") quad x_1 == x + 1 \\ x_2 == x + 2" + } + } + } + }, + { + "id": "tests_timestamp_match_filter_rs__35_5_TsTx_add_rule__timestamp_filtered_recent_leaf__72112b74bfe782ae", + "display_name": "timestamp_filtered_recent_leaf @ tests/timestamp_match_filter.rs:35", + "rule_name": "timestamp_filtered_recent_leaf", + "callee": "TsTx::add_rule", + "file": "tests/timestamp_match_filter.rs", + "offset": 806, + "line": 35, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 806, + "end": 1255 + }, + "pattern_range": { + "start": 889, + "end": 1132 + }, + "action_range": { + "start": 1142, + "end": 1248 + } + }, + "nodes": [ + { + "id": "leaf", + "kind": "query", + "dsl_type": "Leaf", + "label": "leaf: Leaf", + "range": { + "start": 911, + "end": 936 + }, + "inputs": [] + } + ], + "edges": [], + "roots": [ + "leaf" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@1212:1237", + "bound_var": null, + "source_text": "ctx.insert_recent_leaf(n)", + "semantic_text": null, + "referenced_pat_vars": [ + "leaf" + ], + "referenced_action_vars": [ + "n" + ], + "range": { + "start": 1212, + "end": 1237 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "old_leaf.commit()", + "committed_root": "old_leaf", + "referenced_vars": [ + "old_leaf" + ], + "range": { + "start": 531, + "end": 548 + } + }, + { + "id": "seed_1", + "source_text": "new_leaf.commit()", + "committed_root": "new_leaf", + "referenced_vars": [ + "new_leaf" + ], + "range": { + "start": 711, + "end": 728 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "timestamp_filtered_recent_leaf", + "premises": [ + { + "target_id": "leaf", + "label": "leaf: Leaf", + "plain_source": "upright(\"leaf\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"leaf\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "tests_timestamp_match_filter_rs__108_5_TsWindowTx_add_rule__timestamp_window_only_middle_leaf__ffa81fbfbf7c95eb", + "display_name": "timestamp_window_only_middle_leaf", + "rule_name": "timestamp_window_only_middle_leaf", + "callee": "TsWindowTx::add_rule", + "file": "tests/timestamp_match_filter.rs", + "offset": 2755, + "line": 108, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 2755, + "end": 3204 + }, + "pattern_range": { + "start": 2847, + "end": 3081 + }, + "action_range": { + "start": 3091, + "end": 3197 + } + }, + "nodes": [ + { + "id": "leaf", + "kind": "query", + "dsl_type": "WindowNode", + "label": "leaf: WindowNode", + "range": { + "start": 2869, + "end": 2900 + }, + "inputs": [] + } + ], + "edges": [], + "roots": [ + "leaf" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@3161:3186", + "bound_var": null, + "source_text": "ctx.insert_window_leaf(n)", + "semantic_text": null, + "referenced_pat_vars": [ + "leaf" + ], + "referenced_action_vars": [ + "n" + ], + "range": { + "start": 3161, + "end": 3186 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "oldest_leaf.commit()", + "committed_root": "oldest_leaf", + "referenced_vars": [ + "oldest_leaf" + ], + "range": { + "start": 2240, + "end": 2260 + } + }, + { + "id": "seed_1", + "source_text": "middle_leaf.commit()", + "committed_root": "middle_leaf", + "referenced_vars": [ + "middle_leaf" + ], + "range": { + "start": 2444, + "end": 2464 + } + }, + { + "id": "seed_2", + "source_text": "newest_leaf.commit()", + "committed_root": "newest_leaf", + "referenced_vars": [ + "newest_leaf" + ], + "range": { + "start": 2648, + "end": 2668 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "timestamp_window_only_middle_leaf", + "premises": [ + { + "target_id": "leaf", + "label": "leaf: WindowNode", + "plain_source": "upright(\"leaf\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"leaf\"), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $], upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "tests_tx_sessions_rs__98_9_AltSessionTx_add_rule__AddPatAlt__64c8129805d29460", + "display_name": "AddPatAlt", + "rule_name": "AddPatAlt", + "callee": "AltSessionTx::add_rule", + "file": "tests/tx_sessions.rs", + "offset": 3138, + "line": 98, + "column": 9, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 3138, + "end": 3771 + }, + "pattern_range": { + "start": 3220, + "end": 3547 + }, + "action_range": { + "start": 3561, + "end": 3760 + } + }, + "nodes": [ + { + "id": "l", + "kind": "query", + "dsl_type": "Const", + "label": "l: Const", + "range": { + "start": 3241, + "end": 3264 + }, + "inputs": [] + }, + { + "id": "r", + "kind": "query", + "dsl_type": "Const", + "label": "r: Const", + "range": { + "start": 3281, + "end": 3304 + }, + "inputs": [] + }, + { + "id": "p", + "kind": "query", + "dsl_type": "Add", + "label": "p: Add", + "range": { + "start": 3321, + "end": 3348 + }, + "inputs": [ + "l", + "r" + ] + } + ], + "edges": [ + { + "from": "p", + "to": "l", + "kind": "operand", + "index": 0 + }, + { + "from": "p", + "to": "r", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "l", + "r", + "p" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@3680:3703", + "bound_var": "folded", + "source_text": "ctx.insert_const(value)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 3680, + "end": 3703 + } + }, + { + "id": "effect_1", + "effect_id": "effect@3721:3745", + "bound_var": null, + "source_text": "ctx.union(pat.p, folded)", + "semantic_text": null, + "referenced_pat_vars": [ + "p" + ], + "referenced_action_vars": [ + "folded" + ], + "range": { + "start": 3721, + "end": 3745 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "expr.commit()", + "committed_root": "expr", + "referenced_vars": [ + "expr" + ], + "range": { + "start": 2784, + "end": 2797 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "AddPatAlt", + "premises": [ + { + "target_id": "l", + "label": "l: Const", + "plain_source": "l", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ l $]" + }, + { + "target_id": "r", + "label": "r: Const", + "plain_source": "r", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ r $]" + }, + { + "target_id": "p", + "label": "p: Add", + "plain_source": "upright(\"Add\")(l, r)", + "colored_source": "upright(\"Add\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "folded", + "plain_source": "upright(\"Const\")(upright(\"value\"))", + "colored_source": "upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"value\") $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "p", + "label": "p: Add", + "plain_source": "upright(\"Add\")(l, r)", + "colored_source": "upright(\"Add\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "folded", + "plain_source": "upright(\"Const\")(upright(\"value\"))", + "colored_source": "upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"value\") $])" + } + } + ], + "formula_source": { + "plain": "frac(l \\ r \\ upright(\"Add\")(l, r), upright(\"Add\")(l, r) arrow.r.double upright(\"Const\")(upright(\"value\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ l $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ r $] \\ upright(\"Add\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $]), upright(\"Add\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $]) arrow.r.double upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"value\") $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "tests_tx_sessions_rs__118_9_AltSessionTx_add_rule__MulPatAlt__d50c1caafba48d5c", + "display_name": "MulPatAlt", + "rule_name": "MulPatAlt", + "callee": "AltSessionTx::add_rule", + "file": "tests/tx_sessions.rs", + "offset": 3781, + "line": 118, + "column": 9, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 3781, + "end": 4414 + }, + "pattern_range": { + "start": 3863, + "end": 4190 + }, + "action_range": { + "start": 4204, + "end": 4403 + } + }, + "nodes": [ + { + "id": "l", + "kind": "query", + "dsl_type": "Const", + "label": "l: Const", + "range": { + "start": 3884, + "end": 3907 + }, + "inputs": [] + }, + { + "id": "r", + "kind": "query", + "dsl_type": "Const", + "label": "r: Const", + "range": { + "start": 3924, + "end": 3947 + }, + "inputs": [] + }, + { + "id": "p", + "kind": "query", + "dsl_type": "Mul", + "label": "p: Mul", + "range": { + "start": 3964, + "end": 3991 + }, + "inputs": [ + "l", + "r" + ] + } + ], + "edges": [ + { + "from": "p", + "to": "l", + "kind": "operand", + "index": 0 + }, + { + "from": "p", + "to": "r", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "l", + "r", + "p" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@4323:4346", + "bound_var": "folded", + "source_text": "ctx.insert_const(value)", + "semantic_text": null, + "referenced_pat_vars": [], + "referenced_action_vars": [], + "range": { + "start": 4323, + "end": 4346 + } + }, + { + "id": "effect_1", + "effect_id": "effect@4364:4388", + "bound_var": null, + "source_text": "ctx.union(pat.p, folded)", + "semantic_text": null, + "referenced_pat_vars": [ + "p" + ], + "referenced_action_vars": [ + "folded" + ], + "range": { + "start": 4364, + "end": 4388 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "expr.commit()", + "committed_root": "expr", + "referenced_vars": [ + "expr" + ], + "range": { + "start": 2784, + "end": 2797 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "MulPatAlt", + "premises": [ + { + "target_id": "l", + "label": "l: Const", + "plain_source": "l", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ l $]" + }, + { + "target_id": "r", + "label": "r: Const", + "plain_source": "r", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ r $]" + }, + { + "target_id": "p", + "label": "p: Mul", + "plain_source": "upright(\"Mul\")(l, r)", + "colored_source": "upright(\"Mul\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])" + } + ], + "side_conditions": [], + "derivations": [ + { + "target_id": "effect:effect_0", + "label": "folded", + "plain_source": "upright(\"Const\")(upright(\"value\"))", + "colored_source": "upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"value\") $])" + } + ], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_1", + "from": { + "target_id": "p", + "label": "p: Mul", + "plain_source": "upright(\"Mul\")(l, r)", + "colored_source": "upright(\"Mul\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $])" + }, + "to": { + "target_id": "effect:effect_0", + "label": "folded", + "plain_source": "upright(\"Const\")(upright(\"value\"))", + "colored_source": "upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"value\") $])" + } + } + ], + "formula_source": { + "plain": "frac(l \\ r \\ upright(\"Mul\")(l, r), upright(\"Mul\")(l, r) arrow.r.double upright(\"Const\")(upright(\"value\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ l $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ r $] \\ upright(\"Mul\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $]), upright(\"Mul\")(#text(fill: rgb(\"#5F7A8A\"))[$ l $], #text(fill: rgb(\"#5F7A8A\"))[$ r $]) arrow.r.double upright(\"Const\")(#text(fill: rgb(\"#B86A5B\"))[$ upright(\"value\") $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "tests_typed_extract_cost_model_rs__66_5_MyTxExtractCost_add_rule__union_wrappers_for_extract_cost__57c8941de039f311", + "display_name": "union_wrappers_for_extract_cost", + "rule_name": "union_wrappers_for_extract_cost", + "callee": "MyTxExtractCost::add_rule", + "file": "tests/typed_extract_cost_model.rs", + "offset": 1714, + "line": 66, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 1714, + "end": 2235 + }, + "pattern_range": { + "start": 1809, + "end": 2138 + }, + "action_range": { + "start": 2148, + "end": 2228 + } + }, + "nodes": [ + { + "id": "leaf", + "kind": "query", + "dsl_type": "Leaf", + "label": "leaf: Leaf", + "range": { + "start": 1826, + "end": 1851 + }, + "inputs": [] + }, + { + "id": "default_wrap", + "kind": "query", + "dsl_type": "DefaultWrap", + "label": "default_wrap: DefaultWrap", + "range": { + "start": 1864, + "end": 1909 + }, + "inputs": [ + "leaf" + ] + }, + { + "id": "custom_wrap", + "kind": "query", + "dsl_type": "CustomWrap", + "label": "custom_wrap: CustomWrap", + "range": { + "start": 1922, + "end": 1965 + }, + "inputs": [ + "leaf" + ] + } + ], + "edges": [ + { + "from": "default_wrap", + "to": "leaf", + "kind": "operand", + "index": 0 + }, + { + "from": "custom_wrap", + "to": "leaf", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "default_wrap", + "custom_wrap" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@2173:2217", + "bound_var": null, + "source_text": "ctx.union(pat.default_wrap, pat.custom_wrap)", + "semantic_text": null, + "referenced_pat_vars": [ + "custom_wrap", + "default_wrap" + ], + "referenced_action_vars": [], + "range": { + "start": 2173, + "end": 2217 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "leaf.commit()", + "committed_root": "leaf", + "referenced_vars": [ + "leaf" + ], + "range": { + "start": 1425, + "end": 1438 + } + }, + { + "id": "seed_1", + "source_text": "default_wrap.commit()", + "committed_root": "default_wrap", + "referenced_vars": [ + "default_wrap" + ], + "range": { + "start": 1512, + "end": 1533 + } + }, + { + "id": "seed_2", + "source_text": "custom_wrap.commit()", + "committed_root": "custom_wrap", + "referenced_vars": [ + "custom_wrap" + ], + "range": { + "start": 1604, + "end": 1624 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "union_wrappers_for_extract_cost", + "premises": [ + { + "target_id": "default_wrap", + "label": "default_wrap: DefaultWrap", + "plain_source": "upright(\"DefaultWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"DefaultWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + }, + { + "target_id": "custom_wrap", + "label": "custom_wrap: CustomWrap", + "plain_source": "upright(\"CustomWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"CustomWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_0", + "from": { + "target_id": "default_wrap", + "label": "default_wrap: DefaultWrap", + "plain_source": "upright(\"DefaultWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"DefaultWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + }, + "to": { + "target_id": "custom_wrap", + "label": "custom_wrap: CustomWrap", + "plain_source": "upright(\"CustomWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"CustomWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"DefaultWrap\")(upright(\"leaf\")) \\ upright(\"CustomWrap\")(upright(\"leaf\")), upright(\"DefaultWrap\")(upright(\"leaf\")) arrow.r.double upright(\"CustomWrap\")(upright(\"leaf\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"DefaultWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]) \\ upright(\"CustomWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]), upright(\"DefaultWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]) arrow.r.double upright(\"CustomWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "tests_typed_extract_cost_model_rs__146_5_MyTxExtractCost_add_rule__union_wrappers_for_extract_backend__f116669379176a67", + "display_name": "union_wrappers_for_extract_backend", + "rule_name": "union_wrappers_for_extract_backend", + "callee": "MyTxExtractCost::add_rule", + "file": "tests/typed_extract_cost_model.rs", + "offset": 4742, + "line": 146, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 4742, + "end": 5266 + }, + "pattern_range": { + "start": 4840, + "end": 5169 + }, + "action_range": { + "start": 5179, + "end": 5259 + } + }, + "nodes": [ + { + "id": "leaf", + "kind": "query", + "dsl_type": "Leaf", + "label": "leaf: Leaf", + "range": { + "start": 4857, + "end": 4882 + }, + "inputs": [] + }, + { + "id": "default_wrap", + "kind": "query", + "dsl_type": "DefaultWrap", + "label": "default_wrap: DefaultWrap", + "range": { + "start": 4895, + "end": 4940 + }, + "inputs": [ + "leaf" + ] + }, + { + "id": "custom_wrap", + "kind": "query", + "dsl_type": "CustomWrap", + "label": "custom_wrap: CustomWrap", + "range": { + "start": 4953, + "end": 4996 + }, + "inputs": [ + "leaf" + ] + } + ], + "edges": [ + { + "from": "default_wrap", + "to": "leaf", + "kind": "operand", + "index": 0 + }, + { + "from": "custom_wrap", + "to": "leaf", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "default_wrap", + "custom_wrap" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@5204:5248", + "bound_var": null, + "source_text": "ctx.union(pat.default_wrap, pat.custom_wrap)", + "semantic_text": null, + "referenced_pat_vars": [ + "custom_wrap", + "default_wrap" + ], + "referenced_action_vars": [], + "range": { + "start": 5204, + "end": 5248 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "leaf.commit()", + "committed_root": "leaf", + "referenced_vars": [ + "leaf" + ], + "range": { + "start": 4450, + "end": 4463 + } + }, + { + "id": "seed_1", + "source_text": "default_wrap.commit()", + "committed_root": "default_wrap", + "referenced_vars": [ + "default_wrap" + ], + "range": { + "start": 4537, + "end": 4558 + } + }, + { + "id": "seed_2", + "source_text": "custom_wrap.commit()", + "committed_root": "custom_wrap", + "referenced_vars": [ + "custom_wrap" + ], + "range": { + "start": 4629, + "end": 4649 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "union_wrappers_for_extract_backend", + "premises": [ + { + "target_id": "default_wrap", + "label": "default_wrap: DefaultWrap", + "plain_source": "upright(\"DefaultWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"DefaultWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + }, + { + "target_id": "custom_wrap", + "label": "custom_wrap: CustomWrap", + "plain_source": "upright(\"CustomWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"CustomWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_0", + "from": { + "target_id": "default_wrap", + "label": "default_wrap: DefaultWrap", + "plain_source": "upright(\"DefaultWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"DefaultWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + }, + "to": { + "target_id": "custom_wrap", + "label": "custom_wrap: CustomWrap", + "plain_source": "upright(\"CustomWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"CustomWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"DefaultWrap\")(upright(\"leaf\")) \\ upright(\"CustomWrap\")(upright(\"leaf\")), upright(\"DefaultWrap\")(upright(\"leaf\")) arrow.r.double upright(\"CustomWrap\")(upright(\"leaf\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"DefaultWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]) \\ upright(\"CustomWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]), upright(\"DefaultWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]) arrow.r.double upright(\"CustomWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "tests_typed_extract_cost_model_rs__193_5_MyTxExtractCost_add_rule__union_wrappers_for_rustsat_backend__e938b682e247ee52", + "display_name": "union_wrappers_for_rustsat_backend", + "rule_name": "union_wrappers_for_rustsat_backend", + "callee": "MyTxExtractCost::add_rule", + "file": "tests/typed_extract_cost_model.rs", + "offset": 6361, + "line": 193, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 6361, + "end": 6885 + }, + "pattern_range": { + "start": 6459, + "end": 6788 + }, + "action_range": { + "start": 6798, + "end": 6878 + } + }, + "nodes": [ + { + "id": "leaf", + "kind": "query", + "dsl_type": "Leaf", + "label": "leaf: Leaf", + "range": { + "start": 6476, + "end": 6501 + }, + "inputs": [] + }, + { + "id": "default_wrap", + "kind": "query", + "dsl_type": "DefaultWrap", + "label": "default_wrap: DefaultWrap", + "range": { + "start": 6514, + "end": 6559 + }, + "inputs": [ + "leaf" + ] + }, + { + "id": "custom_wrap", + "kind": "query", + "dsl_type": "CustomWrap", + "label": "custom_wrap: CustomWrap", + "range": { + "start": 6572, + "end": 6615 + }, + "inputs": [ + "leaf" + ] + } + ], + "edges": [ + { + "from": "default_wrap", + "to": "leaf", + "kind": "operand", + "index": 0 + }, + { + "from": "custom_wrap", + "to": "leaf", + "kind": "operand", + "index": 0 + } + ], + "roots": [ + "default_wrap", + "custom_wrap" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@6823:6867", + "bound_var": null, + "source_text": "ctx.union(pat.default_wrap, pat.custom_wrap)", + "semantic_text": null, + "referenced_pat_vars": [ + "custom_wrap", + "default_wrap" + ], + "referenced_action_vars": [], + "range": { + "start": 6823, + "end": 6867 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "leaf.commit()", + "committed_root": "leaf", + "referenced_vars": [ + "leaf" + ], + "range": { + "start": 6070, + "end": 6083 + } + }, + { + "id": "seed_1", + "source_text": "default_wrap.commit()", + "committed_root": "default_wrap", + "referenced_vars": [ + "default_wrap" + ], + "range": { + "start": 6156, + "end": 6177 + } + }, + { + "id": "seed_2", + "source_text": "custom_wrap.commit()", + "committed_root": "custom_wrap", + "referenced_vars": [ + "custom_wrap" + ], + "range": { + "start": 6248, + "end": 6268 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "union_wrappers_for_rustsat_backend", + "premises": [ + { + "target_id": "default_wrap", + "label": "default_wrap: DefaultWrap", + "plain_source": "upright(\"DefaultWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"DefaultWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + }, + { + "target_id": "custom_wrap", + "label": "custom_wrap: CustomWrap", + "plain_source": "upright(\"CustomWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"CustomWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_0", + "from": { + "target_id": "default_wrap", + "label": "default_wrap: DefaultWrap", + "plain_source": "upright(\"DefaultWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"DefaultWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + }, + "to": { + "target_id": "custom_wrap", + "label": "custom_wrap: CustomWrap", + "plain_source": "upright(\"CustomWrap\")(upright(\"leaf\"))", + "colored_source": "upright(\"CustomWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"DefaultWrap\")(upright(\"leaf\")) \\ upright(\"CustomWrap\")(upright(\"leaf\")), upright(\"DefaultWrap\")(upright(\"leaf\")) arrow.r.double upright(\"CustomWrap\")(upright(\"leaf\"))) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"DefaultWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]) \\ upright(\"CustomWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]), upright(\"DefaultWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $]) arrow.r.double upright(\"CustomWrap\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"leaf\") $])) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "tests_typed_extract_dynamic_cost_rs__52_5_MyTxDynamicCost_add_rule__union_dynamic_cost_leaves__53a070558ed09b54", + "display_name": "union_dynamic_cost_leaves @ tests/typed_extract_dynamic_cost.rs:52", + "rule_name": "union_dynamic_cost_leaves", + "callee": "MyTxDynamicCost::add_rule", + "file": "tests/typed_extract_dynamic_cost.rs", + "offset": 1483, + "line": 52, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 1483, + "end": 2061 + }, + "pattern_range": { + "start": 1572, + "end": 1793 + }, + "action_range": { + "start": 1803, + "end": 2054 + } + }, + "nodes": [ + { + "id": "lhs", + "kind": "query", + "dsl_type": "Leaf", + "label": "lhs: Leaf", + "range": { + "start": 1589, + "end": 1613 + }, + "inputs": [] + }, + { + "id": "rhs", + "kind": "query", + "dsl_type": "Leaf", + "label": "rhs: Leaf", + "range": { + "start": 1626, + "end": 1650 + }, + "inputs": [] + } + ], + "edges": [], + "roots": [ + "lhs", + "rhs" + ], + "constraints": [], + "action_effects": [ + { + "id": "effect_0", + "effect_id": "effect@2002:2029", + "bound_var": null, + "source_text": "ctx.union(pat.lhs, pat.rhs)", + "semantic_text": null, + "referenced_pat_vars": [ + "lhs", + "rhs" + ], + "referenced_action_vars": [], + "range": { + "start": 2002, + "end": 2029 + } + } + ], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "expensive_leaf.commit()", + "committed_root": "expensive_leaf", + "referenced_vars": [ + "expensive_leaf" + ], + "range": { + "start": 1297, + "end": 1320 + } + }, + { + "id": "seed_1", + "source_text": "cheap_leaf.commit()", + "committed_root": "cheap_leaf", + "referenced_vars": [ + "cheap_leaf" + ], + "range": { + "start": 1380, + "end": 1399 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "union_dynamic_cost_leaves", + "premises": [ + { + "target_id": "lhs", + "label": "lhs: Leaf", + "plain_source": "upright(\"lhs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]" + }, + { + "target_id": "rhs", + "label": "rhs: Leaf", + "plain_source": "upright(\"rhs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $]" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [ + { + "kind": "rewrite", + "id": "effect_0", + "from": { + "target_id": "lhs", + "label": "lhs: Leaf", + "plain_source": "upright(\"lhs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $]" + }, + "to": { + "target_id": "rhs", + "label": "rhs: Leaf", + "plain_source": "upright(\"rhs\")", + "colored_source": "#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $]" + } + } + ], + "formula_source": { + "plain": "frac(upright(\"lhs\") \\ upright(\"rhs\"), upright(\"lhs\") arrow.r.double upright(\"rhs\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] \\ #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $] arrow.r.double #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $]) quad upright(\"if\") quad upright(\"None\")" + } + } + } + }, + { + "id": "tests_typed_lookup_fastpath_rs__42_5_FastTx_add_rule__check_cached_lookup__05c8ff4d9911cdd0", + "display_name": "check_cached_lookup", + "rule_name": "check_cached_lookup", + "callee": "FastTx::add_rule", + "file": "tests/typed_lookup_fastpath.rs", + "offset": 1051, + "line": 42, + "column": 5, + "ok": true, + "error": null, + "pattern": { + "scope": { + "kind": "add_rule_call", + "text_range": { + "start": 1051, + "end": 1448 + }, + "pattern_range": { + "start": 1125, + "end": 1137 + }, + "action_range": { + "start": 1147, + "end": 1441 + } + }, + "nodes": [ + { + "id": "lhs", + "kind": "query_leaf", + "dsl_type": "FastExpr", + "label": "lhs: FastExpr", + "range": { + "start": 483, + "end": 516 + }, + "inputs": [] + }, + { + "id": "rhs", + "kind": "query_leaf", + "dsl_type": "FastExpr", + "label": "rhs: FastExpr", + "range": { + "start": 521, + "end": 554 + }, + "inputs": [] + }, + { + "id": "add", + "kind": "query", + "dsl_type": "FastAdd", + "label": "add: FastAdd", + "range": { + "start": 559, + "end": 596 + }, + "inputs": [ + "lhs", + "rhs" + ] + } + ], + "edges": [ + { + "from": "add", + "to": "lhs", + "kind": "operand", + "index": 0 + }, + { + "from": "add", + "to": "rhs", + "kind": "operand", + "index": 1 + } + ], + "roots": [ + "lhs", + "rhs", + "add" + ], + "constraints": [], + "action_effects": [], + "seed_facts": [ + { + "id": "seed_0", + "source_text": "root.commit()", + "committed_root": "root", + "referenced_vars": [ + "root" + ], + "range": { + "start": 869, + "end": 882 + } + } + ], + "display_templates": [], + "typst_templates": [], + "precedence_templates": [], + "diagnostics": [], + "math_view": { + "rule_name": "check_cached_lookup", + "premises": [ + { + "target_id": "add", + "label": "add: FastAdd", + "plain_source": "upright(\"FastAdd\")(upright(\"lhs\"), upright(\"rhs\"))", + "colored_source": "upright(\"FastAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $])" + } + ], + "side_conditions": [], + "derivations": [], + "conclusions": [], + "formula_source": { + "plain": "frac(upright(\"FastAdd\")(upright(\"lhs\"), upright(\"rhs\")), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")", + "colored": "frac(upright(\"FastAdd\")(#text(fill: rgb(\"#5F7A8A\"))[$ upright(\"lhs\") $], #text(fill: rgb(\"#5F7A8A\"))[$ upright(\"rhs\") $]), upright(\"no conclusion\")) quad upright(\"if\") quad upright(\"None\")" + } + } + } + } + ] +} \ No newline at end of file diff --git a/src/artifact.rs b/src/artifact.rs index 0054eb9..c31c5fa 100644 --- a/src/artifact.rs +++ b/src/artifact.rs @@ -3,16 +3,15 @@ use std::fmt::{Display, Formatter}; use std::path::Path; use std::sync::{Arc, Mutex}; -use egglog::{ - EGraph, EngineSchemaManifest as EgglogEngineSchemaManifest, SchemaFunctionKind, SchemaSortKind, - SerializeConfig, -}; +use egglog::{EGraph, SerializeConfig}; use serde::{Deserialize, Serialize, de::DeserializeOwned}; use serde_json::{Value as JsonValue, json}; use sha2::{Digest, Sha256}; use crate::wrap::{ - Decl, DslFieldKind, DslVariantDecl, PersistedSnapshotUserBaseSortSupport, UserBaseSort, + Decl, DslFieldKind, DslVariantDecl, EgglogCompatExt, + EngineSchemaManifest as EgglogEngineSchemaManifest, PersistedSnapshotUserBaseSortSupport, + SchemaFunctionKind, SchemaSortKind, UserBaseSort, run_ephemeral_rust_rule, user_base_sort_restore_hook, user_base_sort_restore_support, }; @@ -1713,7 +1712,7 @@ pub fn restore_persisted_snapshot_v1( let op_decls = Arc::new(op_decls); let sort_names_by_id = Arc::new(sort_names_by_id); - egglog::prelude::run_ephemeral_rust_rule( + run_ephemeral_rust_rule( egraph, "restore_persisted_snapshot_v1", &[], @@ -1887,7 +1886,7 @@ pub fn restore_persisted_snapshot_v1( } fn resolve_snapshot_values( - ctx: &mut egglog::prelude::RustRuleContext<'_, '_, '_>, + ctx: &mut egglog::prelude::RustRuleContext<'_, '_>, sort_names_by_id: &HashMap, sort_names: &[String], values: &[PersistedSnapshotValue], @@ -1906,7 +1905,7 @@ fn resolve_snapshot_values( } fn resolve_snapshot_value( - ctx: &mut egglog::prelude::RustRuleContext<'_, '_, '_>, + ctx: &mut egglog::prelude::RustRuleContext<'_, '_>, _sort_names_by_id: &HashMap, sort_name: &str, value: &PersistedSnapshotValue, @@ -1923,7 +1922,7 @@ fn resolve_snapshot_value( } fn restore_literal_value( - ctx: &mut egglog::prelude::RustRuleContext<'_, '_, '_>, + ctx: &mut egglog::prelude::RustRuleContext<'_, '_>, sort_name: &str, literal: &PersistedSnapshotLiteralValue, ) -> Result { diff --git a/src/instances/mod.rs b/src/instances/mod.rs index c0561bf..803228d 100644 --- a/src/instances/mod.rs +++ b/src/instances/mod.rs @@ -143,10 +143,36 @@ macro_rules! basic_tx_rx_vt_pr { }; } +#[macro_export] +macro_rules! basic_tx_rx_vt_pr_pf { + ($name:ident) => { + #[eggplant::singleton_getter(ctor = new_with_proof)] + pub struct $name { + tx: eggplant::instances::tx_rx_vt_pr::TxRxVTPR, + } + impl $name { + pub fn egraph() -> std::sync::Arc> { + Self::sgl().egraph.clone() + } + + pub fn reset_for_bench() { + Self::sgl().reset_for_bench(); + } + } + impl eggplant::wrap::NonPatRecSgl for $name { + fn egraph() -> std::sync::Arc> { + Self::sgl().egraph.clone() + } + } + }; +} + #[macro_export] macro_rules! tx_rx_vt_pr { ($tx_name:ident, $pat_rec_name:ident) => { + #[derive(Debug)] pub struct $tx_name; + #[derive(Debug)] pub struct $pat_rec_name; impl $tx_name { @@ -239,6 +265,21 @@ macro_rules! tx_rx_vt_pr { }; } +#[macro_export] +macro_rules! tx_rx_vt_pr_pf { + ($tx_name:ident, $pat_rec_name:ident) => { + eggplant::basic_tx_rx_vt_pr_pf!($tx_name); + eggplant::basic_patttern_recorder!($pat_rec_name); + + impl eggplant::wrap::WithPatRecSgl for $tx_name { + type PatRecSgl = $pat_rec_name; + } + impl eggplant::wrap::WithRxSgl for $pat_rec_name { + type RxSgl = $tx_name; + } + }; +} + #[macro_export] macro_rules! basic_slotted_tx_rx_vt_pr { ($name:ident) => { diff --git a/src/instances/session_runtime.rs b/src/instances/session_runtime.rs index dd22c52..2fd9bf9 100644 --- a/src/instances/session_runtime.rs +++ b/src/instances/session_runtime.rs @@ -1,8 +1,8 @@ use crate::wrap::{ EgglogFunc, EgglogFuncInputs, EgglogFuncOutput, EgglogNode, EgglogRelation, EgglogTy, FactsBuilder, FromBase, LocateVersion, NodeDropper, NodeOwner, NodeSetter, PatId, PatRec, - PatRecSgl, PatVars, RuleCtxHook, RuleRunner, RuleSetId, RunConfig, Rx, SortName, Sym, TableName, - ToDot, Tx, TxCommand, TxCommit, Value, VarName, VersionCtl, + PatRecSgl, PatVars, RuleCtxHook, RuleRunner, RuleSetId, RunConfig, Rx, SortName, Sym, + TableName, ToDot, Tx, TxCommand, TxCommit, Value, VarName, VersionCtl, }; use egglog::EGraph; use egglog_reports::RunReport; @@ -135,9 +135,7 @@ pub fn with_runtime(f: impl FnOnce(&Tx::Runtime) -> R) - f(&state.runtime) } -pub fn with_pat_recorder( - f: impl FnOnce(&Tx::PatRecorder) -> R, -) -> R { +pub fn with_pat_recorder(f: impl FnOnce(&Tx::PatRecorder) -> R) -> R { let state = current_state::(); let pat_recorder = state.pat_recorder.lock().unwrap(); f(&pat_recorder) @@ -171,9 +169,10 @@ impl Session { pub fn run(&self, f: impl FnOnce() -> R) -> R { let key = type_key::(); CURRENT_SESSION_THREADS.with(|slot| { - let previous = slot - .borrow_mut() - .insert(key, ErasedSessionBinding::new::(Arc::clone(&self.state))); + let previous = slot.borrow_mut().insert( + key, + ErasedSessionBinding::new::(Arc::clone(&self.state)), + ); let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(f)); let mut bindings = slot.borrow_mut(); match previous { @@ -205,7 +204,9 @@ impl Session { type_key::(), ErasedSessionBinding::new::(Arc::clone(&self.state)), ); - CURRENT_SESSION_TASKS.scope(RefCell::new(bindings), fut).await + CURRENT_SESSION_TASKS + .scope(RefCell::new(bindings), fut) + .await } pub fn spawn( @@ -368,6 +369,37 @@ impl TxFacade { pub const fn new() -> Self { Self(PhantomData) } + + pub fn reset_for_bench(&self) { + crate::instances::session_runtime::reset_for_bench::(); + } +} + +#[cfg(feature = "viewer")] +impl crate::wrap::EGraphView for TxFacade { + fn egraph(&self) -> Arc> { + with_runtime::(|runtime| TxMarker::runtime_egraph(runtime)) + } + + fn view(&self) -> Result<(), eframe::Error> { + use eggplant_viewer::*; + + let native_options = eframe::NativeOptions::default(); + let egraph = self.egraph(); + let egraph = egraph.lock().unwrap(); + eframe::run_native( + "eggplant_egui_graphs demo", + native_options, + Box::new(|cc| { + Ok(Box::new(EGraphApp::new( + cc, + DemoLayout::Hierarchical, + &egraph, + EmptyH {}.dyn_clone(), + ))) + }), + ) + } } impl NodeOwner for TxFacade { @@ -489,10 +521,10 @@ where rule_set: RuleSetId, pat: impl Fn() -> P, action: impl Fn(&crate::wrap::PRRuleCtx, &P::Valued) - + Send - + Sync - + 'static - + Clone, + + Send + + Sync + + 'static + + Clone, ctx_hook: Option>, ) { with_runtime::(|runtime| { @@ -539,9 +571,22 @@ impl PatRecFacade { } } +impl PatRecFacade +where + PatMarker: SessionPatRecMarker, + PatMarker::TxMarker: SessionTxMarker, +{ + pub fn pats_to_dot(&self, path: impl AsRef) { + with_pat_recorder::(move |pat_rec| pat_rec.pats_to_dot(path)); + } +} + impl NodeOwner for PatRecFacade { type OwnerSpecDataInNode = - <::PatRecorder as NodeOwner>::OwnerSpecDataInNode; + <::PatRecorder as NodeOwner>::OwnerSpecDataInNode< + T, + V, + >; } impl NodeDropper for PatRecFacade { @@ -570,7 +615,9 @@ impl Tx for PatRecFacade { input: ::Ref<'a>, output: ::Ref<'a>, ) { - with_pat_recorder::(|pat_rec| pat_rec.on_func_set::(input, output)); + with_pat_recorder::(|pat_rec| { + pat_rec.on_func_set::(input, output) + }); } fn on_union(&self, node1: &(impl EgglogNode + 'static), node2: &(impl EgglogNode + 'static)) { @@ -590,15 +637,21 @@ impl PatRec for PatRecFacade { } fn on_new_constraint(&self, constraint: impl crate::wrap::IntoConstraintFact) { - with_pat_recorder::(|pat_rec| pat_rec.on_new_constraint(constraint)); + with_pat_recorder::(|pat_rec| { + pat_rec.on_new_constraint(constraint) + }); } fn on_new_table_fact(&self, query_table: TableName, vars: Vec<(VarName, SortName)>) { - with_pat_recorder::(|pat_rec| pat_rec.on_new_table_fact(query_table, vars)); + with_pat_recorder::(|pat_rec| { + pat_rec.on_new_table_fact(query_table, vars) + }); } fn on_new_relation_fact(&self, query_table: TableName, vars: Vec<(VarName, SortName)>) { - with_pat_recorder::(|pat_rec| pat_rec.on_new_relation_fact(query_table, vars)); + with_pat_recorder::(|pat_rec| { + pat_rec.on_new_relation_fact(query_table, vars) + }); } fn on_record_start(&self) { diff --git a/src/instances/tx_rx_vt_pr.rs b/src/instances/tx_rx_vt_pr.rs index 241c621..595fa8b 100644 --- a/src/instances/tx_rx_vt_pr.rs +++ b/src/instances/tx_rx_vt_pr.rs @@ -1,4 +1,3 @@ -use crate::wrap::rule::{PremiseProofScope, empty_premise_proofs}; use crate::{ etc::{Escape, quote, topo_sort}, wrap::*, @@ -6,23 +5,18 @@ use crate::{ use core::panic; use dashmap::DashMap; use egglog::ast::{Expr, Fact}; +use egglog::ast::{RustSpan, Span}; use egglog::{ EGraph, SerializeConfig, ast::Facts, - prelude::{add_ruleset, run_ruleset}, span, util::{IndexMap, IndexSet}, }; -use egglog::{ - ast::{RustSpan, Span}, - prelude::{rust_rule, rust_rule_with_metadata}, -}; use egglog_reports::RunReport; use graphviz_rust::dot_structures::Attribute; use petgraph::prelude::StableDiGraph; -use std::collections::HashSet; use std::{ - collections::HashMap, + collections::{HashMap, HashSet}, path::Path, sync::{Arc, Mutex}, }; @@ -47,14 +41,6 @@ pub struct TxRxVTPR { commit_counter: Mutex, } -#[derive(Clone)] -struct PremiseProofSpec { - /// Freshened name of the `{Ctor}ViewProof` function (e.g. `@MulViewProof`). - view_proof_func: Arc, - /// Slot indices into the rust_rule callback `values` slice for this premise. - key_slots: Arc<[usize]>, -} - #[allow(unused)] #[derive(Debug)] pub struct CommitCheckPoint { @@ -68,6 +54,7 @@ impl TxRxVTPR { pub fn clear_egraph(&self) { let mut egraph = self.egraph.lock().unwrap(); self.sym2value_map.clear(); + clear_compat_state(&egraph); *egraph = EGraph::default(); } @@ -90,18 +77,26 @@ impl TxRxVTPR { // Reset the underlying egraph but keep the schema in sync with the current inventory. // Otherwise rule registration (typechecking) will panic because sorts are missing. - let proofs_enabled = self.egraph.lock().unwrap().are_proofs_enabled(); + let mut egraph_guard = self.egraph.lock().unwrap(); + clear_compat_state(&egraph_guard); + let proofs_enabled = egraph_guard.are_proofs_enabled(); let mut egraph = if proofs_enabled { EGraph::new_with_proofs() } else { EGraph::default() }; Self::add_eggplant_sorts(&mut egraph); - let type_defs = EgglogTypeRegistry::collect_type_defs(); + // Proof egraphs need the filtered schema too: upstream egglog rejects presort-backed + // container sorts and other proof-incompatible declarations during type registration. + let type_defs = if proofs_enabled { + EgglogTypeRegistry::collect_type_defs_for_proofs() + } else { + EgglogTypeRegistry::collect_type_defs() + }; egraph .run_program(type_defs) .expect("reset_for_bench: failed to (re)register type definitions"); - *self.egraph.lock().unwrap() = egraph; + *egraph_guard = egraph; } // collect all lastest ancestors of cur_sym, without cur_sym pub fn collect_latest_ancestors(&self, cur_sym: Sym, index_set: &mut IndexSet) { @@ -243,7 +238,8 @@ impl TxRxVTPR { // proof_store: Mutex::new(ProofStore::default()), commit_counter: Mutex::new(0), }; - let type_defs = EgglogTypeRegistry::collect_type_defs(); + // Proof mode gets the same filtered schema subset as the bench reset path. + let type_defs = EgglogTypeRegistry::collect_type_defs_for_proofs(); for def in type_defs { tx.send(TxCommand::NativeCommand { command: def }); } @@ -276,6 +272,271 @@ impl TxRxVTPR { self.prove_eq_pretty_raw(T::TY_NAME, lhs.val, rhs.val) } + /// Return a pretty proof that one value's extracted term exists. + /// + /// This wraps egglog's `(prove )` command. For equality proofs between + /// two values, use `prove_eq_pretty_raw` / `prove_eq_pretty` instead. + pub fn prove_pretty_raw( + &self, + sort_name: &str, + value: egglog::Value, + ) -> Result { + let mut egraph = self.egraph.lock().unwrap(); + if !egraph.are_proofs_enabled() { + return Err(egglog::Error::BackendError( + "prove_pretty_raw requires EGraph::new_with_proofs".into(), + )); + } + egraph.prove_value_pretty(sort_name, value) + } + + pub fn prove_pretty(&self, value: Value) -> Result { + self.prove_pretty_raw(T::TY_NAME, value.val) + } + + /// Return a Typst document for a proof that one value's extracted term exists. + pub fn prove_typst_raw( + &self, + sort_name: &str, + value: egglog::Value, + rules_template_path: impl AsRef, + ) -> Result { + self.prove_typst_raw_with_options(sort_name, value, rules_template_path, false) + } + + pub fn prove_typst_raw_with_options( + &self, + sort_name: &str, + value: egglog::Value, + rules_template_path: impl AsRef, + concise: bool, + ) -> Result { + let templates = ProofRulesTemplateIndex::from_path(rules_template_path)?; + self.prove_typst_raw_with_templates_and_options(sort_name, value, &templates, concise) + } + + /// Return a Typst document using the default template lookup. + pub fn prove_typst_raw_default_template( + &self, + sort_name: &str, + value: egglog::Value, + ) -> Result { + self.prove_typst_raw_default_template_with_options(sort_name, value, false) + } + + pub fn prove_typst_raw_default_template_with_options( + &self, + sort_name: &str, + value: egglog::Value, + concise: bool, + ) -> Result { + let templates = ProofRulesTemplateIndex::from_default_path()?; + self.prove_typst_raw_with_templates_and_options(sort_name, value, &templates, concise) + } + + pub fn prove_typst_raw_with_templates( + &self, + sort_name: &str, + value: egglog::Value, + templates: &ProofRulesTemplateIndex, + ) -> Result { + self.prove_typst_raw_with_templates_and_options(sort_name, value, templates, false) + } + + pub fn prove_typst_raw_with_templates_and_options( + &self, + sort_name: &str, + value: egglog::Value, + templates: &ProofRulesTemplateIndex, + concise: bool, + ) -> Result { + let proof = self.prove_pretty_raw(sort_name, value)?; + Ok(render_value_proof_text_typst_with_options( + &proof, templates, concise, + )) + } + + pub fn prove_typst( + &self, + value: Value, + rules_template_path: impl AsRef, + ) -> Result { + self.prove_typst_with_options(value, rules_template_path, false) + } + + pub fn prove_typst_with_options( + &self, + value: Value, + rules_template_path: impl AsRef, + concise: bool, + ) -> Result { + self.prove_typst_raw_with_options(T::TY_NAME, value.val, rules_template_path, concise) + } + + pub fn prove_typst_with_default_template( + &self, + value: Value, + ) -> Result { + self.prove_typst_with_default_template_and_options(value, false) + } + + pub fn prove_typst_with_default_template_and_options( + &self, + value: Value, + concise: bool, + ) -> Result { + self.prove_typst_raw_default_template_with_options(T::TY_NAME, value.val, concise) + } + + /// Return an SVG rendering of a proof using rule cards from `rules.template`. + /// + /// The proof text still comes from egglog's proof formatter first. Eggplant then + /// turns that proof into a Typst document, resolves `(name "...")` rule-name + /// fragments against the generated Rust-source `rules.template`, and asks the + /// `typst` CLI to compile the document to SVG. + pub fn prove_eq_svg_raw( + &self, + sort_name: &str, + lhs: egglog::Value, + rhs: egglog::Value, + rules_template_path: impl AsRef, + ) -> Result { + let templates = ProofRulesTemplateIndex::from_path(rules_template_path)?; + self.prove_eq_svg_raw_with_templates(sort_name, lhs, rhs, &templates) + } + + /// Return an SVG rendering using the default template lookup. + /// + /// The default path is `$EGGPLANT_RULES_TEMPLATE` when set, otherwise + /// `$CARGO_MANIFEST_DIR/rules.template`. + pub fn prove_eq_svg_raw_default_template( + &self, + sort_name: &str, + lhs: egglog::Value, + rhs: egglog::Value, + ) -> Result { + let templates = ProofRulesTemplateIndex::from_default_path()?; + self.prove_eq_svg_raw_with_templates(sort_name, lhs, rhs, &templates) + } + + pub fn prove_eq_svg_raw_with_templates( + &self, + sort_name: &str, + lhs: egglog::Value, + rhs: egglog::Value, + templates: &ProofRulesTemplateIndex, + ) -> Result { + let proof = self.prove_eq_pretty_raw(sort_name, lhs, rhs)?; + render_proof_text_svg(&proof, templates) + } + + pub fn prove_eq_svg( + &self, + lhs: Value, + rhs: Value, + rules_template_path: impl AsRef, + ) -> Result { + self.prove_eq_svg_raw(T::TY_NAME, lhs.val, rhs.val, rules_template_path) + } + + pub fn prove_eq_svg_with_default_template( + &self, + lhs: Value, + rhs: Value, + ) -> Result { + self.prove_eq_svg_raw_default_template(T::TY_NAME, lhs.val, rhs.val) + } + + pub fn prove_svg_raw( + &self, + sort_name: &str, + value: egglog::Value, + rules_template_path: impl AsRef, + ) -> Result { + self.prove_svg_raw_with_options(sort_name, value, rules_template_path, false) + } + + pub fn prove_svg_raw_with_options( + &self, + sort_name: &str, + value: egglog::Value, + rules_template_path: impl AsRef, + concise: bool, + ) -> Result { + let templates = ProofRulesTemplateIndex::from_path(rules_template_path)?; + self.prove_svg_raw_with_templates_and_options(sort_name, value, &templates, concise) + } + + pub fn prove_svg_raw_default_template( + &self, + sort_name: &str, + value: egglog::Value, + ) -> Result { + self.prove_svg_raw_default_template_with_options(sort_name, value, false) + } + + pub fn prove_svg_raw_default_template_with_options( + &self, + sort_name: &str, + value: egglog::Value, + concise: bool, + ) -> Result { + let templates = ProofRulesTemplateIndex::from_default_path()?; + self.prove_svg_raw_with_templates_and_options(sort_name, value, &templates, concise) + } + + pub fn prove_svg_raw_with_templates( + &self, + sort_name: &str, + value: egglog::Value, + templates: &ProofRulesTemplateIndex, + ) -> Result { + self.prove_svg_raw_with_templates_and_options(sort_name, value, templates, false) + } + + pub fn prove_svg_raw_with_templates_and_options( + &self, + sort_name: &str, + value: egglog::Value, + templates: &ProofRulesTemplateIndex, + concise: bool, + ) -> Result { + let proof = self.prove_pretty_raw(sort_name, value)?; + render_value_proof_text_svg_with_options(&proof, templates, concise) + } + + pub fn prove_svg( + &self, + value: Value, + rules_template_path: impl AsRef, + ) -> Result { + self.prove_svg_with_options(value, rules_template_path, false) + } + + pub fn prove_svg_with_options( + &self, + value: Value, + rules_template_path: impl AsRef, + concise: bool, + ) -> Result { + self.prove_svg_raw_with_options(T::TY_NAME, value.val, rules_template_path, concise) + } + + pub fn prove_svg_with_default_template( + &self, + value: Value, + ) -> Result { + self.prove_svg_with_default_template_and_options(value, false) + } + + pub fn prove_svg_with_default_template_and_options( + &self, + value: Value, + concise: bool, + ) -> Result { + self.prove_svg_raw_default_template_with_options(T::TY_NAME, value.val, concise) + } + /// Prove an equality between two *surface* expressions (AST). /// /// `sort_name` selects which UF/UFProof tables to use for exporting the proof. @@ -291,17 +552,130 @@ impl TxRxVTPR { "prove_eq_pretty_expr_ast requires EGraph::new_with_proofs".into(), )); } + let sort = egraph + .get_sort_by_name(sort_name) + .ok_or_else(|| egglog::Error::BackendError(format!("unknown sort {sort_name}")))? + .clone(); + if !sort.is_eq_sort() { + return Err(egglog::Error::BackendError(format!( + "prove_eq_pretty_expr_ast requires eq sort, got {}", + sort.name() + ))); + } egraph.push(); let res = (|| { - let (_lhs_sort, lhs_value) = egraph.eval_expr(&lhs)?; - let (_rhs_sort, rhs_value) = egraph.eval_expr(&rhs)?; - egraph.prove_values_equal_pretty(sort_name, lhs_value, rhs_value) + let program = format!("(prove (= {lhs} {rhs}))"); + let outputs = egraph.parse_and_run_program(None, &program)?; + outputs + .into_iter() + .find_map(|output| match output { + egglog::CommandOutput::ProveExists { + proof_store, + proof_id, + } => Some(proof_store.proof_to_string(proof_id)), + _ => None, + }) + .ok_or_else(|| { + egglog::Error::BackendError("prove command did not produce a proof".into()) + }) })(); egraph.pop()?; res } + /// Prove one surface fact or constructor expression. + /// + /// This is the eggplant wrapper for egglog's `(prove )` path. It is + /// useful when the proposition is "this term/fact exists" rather than + /// "these two terms are equal". + pub fn prove_pretty_expr_ast(&self, expr: egglog::ast::Expr) -> Result { + let mut egraph = self.egraph.lock().unwrap(); + if !egraph.are_proofs_enabled() { + return Err(egglog::Error::BackendError( + "prove_pretty_expr_ast requires EGraph::new_with_proofs".into(), + )); + } + + egraph.push(); + let res = (|| { + let program = format!("(prove {expr})"); + let outputs = egraph.parse_and_run_program(None, &program)?; + outputs + .into_iter() + .find_map(|output| match output { + egglog::CommandOutput::ProveExists { + proof_store, + proof_id, + } => Some(proof_store.proof_to_string(proof_id)), + _ => None, + }) + .ok_or_else(|| { + egglog::Error::BackendError("prove command did not produce a proof".into()) + }) + })(); + egraph.pop()?; + res + } + + pub fn prove_eq_svg_expr_ast( + &self, + sort_name: &str, + lhs: egglog::ast::Expr, + rhs: egglog::ast::Expr, + rules_template_path: impl AsRef, + ) -> Result { + let templates = ProofRulesTemplateIndex::from_path(rules_template_path)?; + self.prove_eq_svg_expr_ast_with_templates(sort_name, lhs, rhs, &templates) + } + + pub fn prove_eq_svg_expr_ast_default_template( + &self, + sort_name: &str, + lhs: egglog::ast::Expr, + rhs: egglog::ast::Expr, + ) -> Result { + let templates = ProofRulesTemplateIndex::from_default_path()?; + self.prove_eq_svg_expr_ast_with_templates(sort_name, lhs, rhs, &templates) + } + + pub fn prove_eq_svg_expr_ast_with_templates( + &self, + sort_name: &str, + lhs: egglog::ast::Expr, + rhs: egglog::ast::Expr, + templates: &ProofRulesTemplateIndex, + ) -> Result { + let proof = self.prove_eq_pretty_expr_ast(sort_name, lhs, rhs)?; + render_proof_text_svg(&proof, templates) + } + + pub fn prove_svg_expr_ast( + &self, + expr: egglog::ast::Expr, + rules_template_path: impl AsRef, + ) -> Result { + let templates = ProofRulesTemplateIndex::from_path(rules_template_path)?; + self.prove_svg_expr_ast_with_templates(expr, &templates) + } + + pub fn prove_svg_expr_ast_default_template( + &self, + expr: egglog::ast::Expr, + ) -> Result { + let templates = ProofRulesTemplateIndex::from_default_path()?; + self.prove_svg_expr_ast_with_templates(expr, &templates) + } + + pub fn prove_svg_expr_ast_with_templates( + &self, + expr: egglog::ast::Expr, + templates: &ProofRulesTemplateIndex, + ) -> Result { + let proof = self.prove_pretty_expr_ast(expr)?; + render_proof_text_svg(&proof, templates) + } + /// Check whether an e-graph `Value` is in the same e-class as a given surface expression (AST). /// /// This evaluates `expr` using egglog's `eval_expr` (inside a `push/pop` scope) and compares @@ -735,6 +1109,10 @@ impl TxCommit for TxRxVTPR { ); // build check point let ruleset_name = format!("{}_ruleset", rule_name); + let proofs_enabled = { + let egraph = self.egraph.lock().unwrap(); + egraph.are_proofs_enabled() + }; let sym2value_map = Arc::clone(&self.sym2value_map); let topo_sorted_nodes_clone = topo_sorted_nodes.clone(); @@ -742,17 +1120,47 @@ impl TxCommit for TxRxVTPR { log::debug!("sorted to be {:?}", topo_sorted_nodes); let map_clone = self.map.clone(); - // sue add_rule API to create rule let mut egraph = self.egraph.lock().unwrap(); - egglog::prelude::add_ruleset(&mut egraph, &ruleset_name).unwrap(); + add_ruleset(&mut egraph, &ruleset_name).unwrap(); let hook = RuleHookObj(ctx_hook); + + let (vars, facts) = if proofs_enabled { + let trigger_name = format!( + "__eggplant_commit_trigger_{}", + self.commit_counter.lock().unwrap() + ); + egraph + .parse_and_run_program( + None, + &format!("(function {trigger_name} () Unit :merge old)"), + ) + .unwrap(); + egraph + .parse_and_run_program(None, &format!("(set ({trigger_name}) ())")) + .unwrap(); + let unit_sort = egraph + .get_sort_by_name("Unit") + .expect("Unit sort should be registered") + .clone(); + ( + vec![("__eggplant_commit_trigger", unit_sort)], + Facts(vec![Fact::Eq( + span!(), + Expr::Call(span!(), trigger_name, vec![]), + Expr::Var(span!(), "__eggplant_commit_trigger".to_owned()), + )]), + ) + } else { + (Vec::new(), Facts(vec![])) + }; + let rule_rst = rust_rule( &mut egraph, format!("commit{}", self.commit_counter.lock().unwrap()).as_str(), ruleset_name.as_str(), - &[], - Facts(vec![]), - move |ctx, _| { + &vars, + facts, + move |ctx, _values| { let ctx = RuleCtx::new(ctx, hook.clone()); let sym2value_map = sym2value_map.clone(); for &sym in &backup_staged_new_syms_for_rule { @@ -762,6 +1170,7 @@ impl TxCommit for TxRxVTPR { let value = node.egglog.native_egglog(&ctx, &sym2value_map); // store sym value pair to sym_to_value_map sym2value_map.insert(sym, value); + ctx.insert_timestamp_for_value(node.egglog.ty_name(), value); log::debug!("Added node {} to sym_to_value_map using native_egglog", sym); } } @@ -774,6 +1183,7 @@ impl TxCommit for TxRxVTPR { let value = node.egglog.native_egglog(&ctx, &sym2value_map); // store sym value pair to sym_to_value_map sym2value_map.insert(sym, value); + ctx.insert_timestamp_for_value(node.egglog.ty_name(), value); log::debug!( "Update node {} to sym_to_value_map using native_egglog", sym @@ -943,67 +1353,17 @@ impl RuleRunner for TxRxVTPR { vars.push((var, sort)); } } - log::debug!("{:#?}", facts); - log::debug!("{:#?}", vars); + log::debug!("add_rule facts for {rule_name}: {facts:#?}"); + log::debug!("add_rule vars for {rule_name}: {vars:#?}"); let rust_rule_name = Arc::::from(rule_name.to_owned()); - let proofs_enabled = egraph.are_proofs_enabled(); let binding_var_slots: HashMap, usize> = vars .iter() .enumerate() .map(|(idx, (name, _))| (Arc::::from(name.as_str()), idx)) .collect(); let decode_plan = Arc::new(pat_vars.build_decode_plan(&binding_var_slots)); - let premise_specs: Arc<[PremiseProofSpec]> = if proofs_enabled { - let mut specs = Vec::new(); - for fact in facts.iter() { - let Fact::Eq(_, lhs, rhs) = fact else { - continue; - }; - let (out, head, args) = match (lhs, rhs) { - (Expr::Var(_, out), Expr::Call(_, head, args)) => (out, head, args), - (Expr::Call(_, head, args), Expr::Var(_, out)) => (out, head, args), - _ => continue, - }; - let mut key_slots: Vec = Vec::with_capacity(args.len() + 1); - for arg in args.iter() { - match arg { - Expr::Var(_, v) => key_slots.push( - *binding_var_slots - .get(v.as_str()) - .unwrap_or_else(|| panic!("missing premise arg binding {}", v)), - ), - _ => { - key_slots.clear(); - break; - } - } - } - if key_slots.is_empty() { - continue; - } - key_slots.push( - *binding_var_slots - .get(out.as_str()) - .unwrap_or_else(|| panic!("missing premise out binding {}", out)), - ); - - let view_proof_func = match egraph.proof_view_proof_name(head) { - Ok(name) => Arc::::from(name.to_owned()), - Err(_) => { - continue; - } - }; - specs.push(PremiseProofSpec { - view_proof_func, - key_slots: Arc::from(key_slots.into_boxed_slice()), - }); - } - Arc::from(specs.into_boxed_slice()) - } else { - Arc::from(Vec::::new().into_boxed_slice()) - }; let hook = RuleHookObj(ctx_hook); let rst = rust_rule_with_metadata( &mut egraph, @@ -1016,25 +1376,6 @@ impl RuleRunner for TxRxVTPR { Facts(facts), move |ctx, values| { let mut ctx = PRRuleCtx::new(ctx, hook.clone()); - let _premise_scope = if proofs_enabled { - let premise_proofs: Arc<[egglog::Value]> = if premise_specs.is_empty() { - empty_premise_proofs() - } else { - let mut proofs = Vec::with_capacity(premise_specs.len()); - for spec in premise_specs.iter() { - let mut key = Vec::with_capacity(spec.key_slots.len()); - for &slot in spec.key_slots.iter() { - key.push(values[slot]); - } - let prf = ctx.ctx.insert(spec.view_proof_func.as_ref(), &key); - proofs.push(prf); - } - Arc::from(proofs.into_boxed_slice()) - }; - Some(PremiseProofScope::enter(premise_proofs)) - } else { - None - }; let valued_pat_vars = P::decode_with_plan(values, &[], decode_plan.as_ref()); action(&mut ctx, &valued_pat_vars); Some(()) @@ -1062,13 +1403,16 @@ impl RuleRunner for TxRxVTPR { #[track_caller] fn run_ruleset(&self, ruleset_id: RuleSetId, until: RunConfig) -> RunReport { let mut egraph = self.egraph.lock().unwrap(); + // Proof egraphs must go through the compat run_ruleset path so egglog emits + // proof-aware CommandOutput records. The plain step_rules fast path is only for + // non-proof execution. match until { RunConfig::Sat => { let mut run_report = RunReport::default(); loop { let iter_report = if egraph.are_proofs_enabled() { - let outputs = - egglog::prelude::run_ruleset(&mut egraph, ruleset_id.0).unwrap(); + let outputs = run_ruleset(&mut egraph, ruleset_id.0).unwrap(); + log::debug!("proof run_ruleset raw outputs: {outputs:#?}"); outputs .into_iter() .find_map(|o| match o { @@ -1091,8 +1435,8 @@ impl RuleRunner for TxRxVTPR { if egraph.are_proofs_enabled() { let mut run_report = RunReport::default(); for _ in 0..times { - let outputs = - egglog::prelude::run_ruleset(&mut egraph, ruleset_id.0).unwrap(); + let outputs = run_ruleset(&mut egraph, ruleset_id.0).unwrap(); + log::debug!("proof run_ruleset raw outputs: {outputs:#?}"); let iter_report = outputs .into_iter() .find_map(|o| match o { @@ -1114,7 +1458,8 @@ impl RuleRunner for TxRxVTPR { } RunConfig::Once => { if egraph.are_proofs_enabled() { - let outputs = egglog::prelude::run_ruleset(&mut egraph, ruleset_id.0).unwrap(); + let outputs = run_ruleset(&mut egraph, ruleset_id.0).unwrap(); + log::debug!("proof run_ruleset raw outputs: {outputs:#?}"); outputs .into_iter() .find_map(|o| match o { diff --git a/src/instances/tx_rx_vt_pr_slot/tx_rx_vt_pr_slot.rs b/src/instances/tx_rx_vt_pr_slot/tx_rx_vt_pr_slot.rs index 37ca758..b47f054 100644 --- a/src/instances/tx_rx_vt_pr_slot/tx_rx_vt_pr_slot.rs +++ b/src/instances/tx_rx_vt_pr_slot/tx_rx_vt_pr_slot.rs @@ -1,6 +1,5 @@ #[cfg(feature = "viewer")] use crate::prelude::SlottedPatRecorder; -use crate::wrap::rule::{PremiseProofScope, empty_premise_proofs}; use crate::{ etc::{Escape, quote, topo_sort}, prelude::{SlotMeta, SlotWorkAreaNode}, @@ -8,17 +7,13 @@ use crate::{ }; use core::panic; use dashmap::DashMap; +use egglog::ast::{RustSpan, Span}; use egglog::{ EGraph, SerializeConfig, ast::Facts, - prelude::{add_ruleset, run_ruleset}, span, util::{IndexMap, IndexSet}, }; -use egglog::{ - ast::{RustSpan, Span}, - prelude::{rust_rule, rust_rule_with_metadata}, -}; use egglog_reports::RunReport; use graphviz_rust::dot_structures::Attribute; use petgraph::prelude::StableDiGraph; @@ -64,6 +59,7 @@ impl SlottedTxRxVTPR { pub fn clear_egraph(&self) { let mut egraph = self.egraph.lock().unwrap(); self.sym2value_map.clear(); + clear_compat_state(&egraph); *egraph = EGraph::default(); } // collect all lastest ancestors of cur_sym, without cur_sym @@ -214,7 +210,8 @@ impl SlottedTxRxVTPR { commit_counter: Mutex::new(0), sym2meta: Default::default(), }; - let type_defs = EgglogTypeRegistry::collect_type_defs(); + // Proof mode gets the same filtered schema subset as the non-slotted path. + let type_defs = EgglogTypeRegistry::collect_type_defs_for_proofs(); for def in type_defs { tx.send(TxCommand::NativeCommand { command: def }); } @@ -662,7 +659,7 @@ impl TxCommit for SlottedTxRxVTPR { // sue add_rule API to create rule let mut egraph = self.egraph.lock().unwrap(); - egglog::prelude::add_ruleset(&mut egraph, &ruleset_name).unwrap(); + add_ruleset(&mut egraph, &ruleset_name).unwrap(); let hook = RuleHookObj(ctx_hook); let rule_rst = rust_rule( &mut egraph, @@ -680,6 +677,7 @@ impl TxCommit for SlottedTxRxVTPR { let value = node.egglog.native_egglog(&ctx, &sym2value_map); // store sym value pair to sym_to_value_map sym2value_map.insert(sym, value); + ctx.insert_timestamp_for_value(node.egglog.ty_name(), value); log::debug!("Added node {} to sym_to_value_map using native_egglog", sym); } } @@ -692,6 +690,7 @@ impl TxCommit for SlottedTxRxVTPR { let value = node.egglog.native_egglog(&ctx, &sym2value_map); // store sym value pair to sym_to_value_map sym2value_map.insert(sym, value); + ctx.insert_timestamp_for_value(node.egglog.ty_name(), value); log::debug!( "Update node {} to sym_to_value_map using native_egglog", sym @@ -851,7 +850,6 @@ impl RuleRunner for SlottedTxRxVTPR { log::debug!("{:#?}", facts); log::debug!("{:#?}", vars); - let proofs_enabled = egraph.are_proofs_enabled(); let binding_var_slots: HashMap, usize> = vars .iter() .enumerate() @@ -868,13 +866,8 @@ impl RuleRunner for SlottedTxRxVTPR { .map(|x| (x.0.as_str(), x.1.clone())) .collect::>(), Facts(facts), - move |ctx: &mut egglog::prelude::RustRuleContext<'_, '_, '_>, values| { + move |ctx: &mut egglog::prelude::RustRuleContext<'_, '_>, values| { let mut ctx = PRRuleCtx::new(ctx, hook.clone()); - let _premise_scope = if proofs_enabled { - Some(PremiseProofScope::enter(empty_premise_proofs())) - } else { - None - }; let valued_pat_vars = P::decode_with_plan(values, &metas, decode_plan.as_ref()); action(&mut ctx, &valued_pat_vars); Some(()) @@ -901,14 +894,16 @@ impl RuleRunner for SlottedTxRxVTPR { #[track_caller] fn run_ruleset(&self, ruleset_id: RuleSetId, until: RunConfig) -> RunReport { + // Proof egraphs must go through the compat run_ruleset path so egglog emits + // proof-aware CommandOutput records. The plain step_rules fast path is only for + // non-proof execution. match until { RunConfig::Sat => { let mut egraph = self.egraph.lock().unwrap(); let mut run_report = RunReport::default(); loop { let iter_report = if egraph.are_proofs_enabled() { - let outputs = - egglog::prelude::run_ruleset(&mut egraph, ruleset_id.0).unwrap(); + let outputs = run_ruleset(&mut egraph, ruleset_id.0).unwrap(); outputs .into_iter() .find_map(|o| match o { @@ -931,8 +926,7 @@ impl RuleRunner for SlottedTxRxVTPR { let mut run_report = RunReport::default(); for _ in 0..times { let iter_report = if egraph.are_proofs_enabled() { - let outputs = - egglog::prelude::run_ruleset(&mut egraph, ruleset_id.0).unwrap(); + let outputs = run_ruleset(&mut egraph, ruleset_id.0).unwrap(); outputs .into_iter() .find_map(|o| match o { @@ -950,7 +944,7 @@ impl RuleRunner for SlottedTxRxVTPR { RunConfig::Once => { let mut egraph = self.egraph.lock().unwrap(); let run_report = if egraph.are_proofs_enabled() { - let outputs = egglog::prelude::run_ruleset(&mut egraph, ruleset_id.0).unwrap(); + let outputs = run_ruleset(&mut egraph, ruleset_id.0).unwrap(); outputs .into_iter() .find_map(|o| match o { diff --git a/src/lib.rs b/src/lib.rs index b95220f..366bab6 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,5 +1,8 @@ +extern crate self as eggplant; + pub mod artifact; mod butler_portugal; +pub mod helpers; pub mod instances; pub mod prelude; pub mod schema; diff --git a/src/prelude.rs b/src/prelude.rs index 97e7c19..c2d7a89 100644 --- a/src/prelude.rs +++ b/src/prelude.rs @@ -18,6 +18,26 @@ pub use crate::artifact::{ dsl_runtime_fingerprint, engine_schema_fingerprint, read_binary_artifact_header, read_binary_artifact_header_from_file, restore_persisted_snapshot_v1, }; +pub use crate::helpers::bench_cli::{ + DEFAULT_EXTRACTORS, ExtractBenchCliArgs, TimelineExportCliArgs, parse_extract_bench_args, + parse_timeline_export_args, timeline_markdown_asset_path, timeline_markdown_output_path, + timeline_plot_output_path, +}; +pub use crate::helpers::progress::{ + BenchProgress, TimelineExtractMetric, format_bytes, format_duration, format_optional_bytes, + format_optional_duration, format_optional_ms, +}; +#[cfg(feature = "timeline-plot")] +pub use crate::helpers::report::write_timeline_plot_png; +pub use crate::helpers::report::{ + ExtractReportRow, print_extract_comparison_report, print_extract_run_configuration, + render_timeline_markdown_report, render_timeline_markdown_report_with_plot, + write_timeline_markdown_report, write_timeline_markdown_report_with_plot, +}; +pub use crate::helpers::runtime::{ + current_peak_memory_bytes, duration_from_ms, duration_to_ms, elapsed_ms, gib_to_bytes, + run_with_timeout_payload, +}; pub use crate::instances::pat_rec::*; pub use crate::instances::session_runtime::Session; pub use crate::instances::tx::*; @@ -40,12 +60,24 @@ pub use crate::wrap::constraint::{ pub use crate::wrap::sorts::set::SetContainer; pub use crate::wrap::sorts::vec::VecContainer; pub use crate::wrap::{ - AsHandle, BaseVar, Commit, EgglogNode, ExtractBackend, ExtractNodeSgl, ExtractSgl, FromBase, - Insertable, LocateVersion, NonPatRecSgl, PEq, PatRecSgl, QuerySlot, RenderedTemplateField, - RuleRunnerSgl, RuleSetId, RunConfig, RustsatExtractConfig, RxSgl, SingletonGetter, SlotVarID, - SlottedPatRecSgl, ToDot, ToDotSgl, TxCommit, TxCommitSgl, TxSgl, Value, - render_template_with_precedence, render_variant_display, render_variant_typst, + AsHandle, BaseVar, Commit, EBoostExtractConfig, EBoostLayeredConfig, EgglogCompatExt, + EgglogEnumVariantTy, EgglogNode, EgglogTy, ExtractBackend, ExtractNodeSgl, ExtractSgl, + FromBase, FunctionId, Insertable, LocateVersion, NonPatRecSgl, OwnedFunctionRow, PEq, + PatRecSgl, ProofRuleTemplate, ProofRuleTemplateMatch, ProofRulesTemplateIndex, + ProofSvgFormatter, QuerySlot, RawEGraphNode, RenderedTemplateField, RuleRunnerSgl, RuleSetId, + RunConfig, RunSchedule, RunScheduleBuilder, RustsatExtractConfig, RxSgl, SchemaFunctionKind, + SchemaSortKind, SingletonGetter, SlotVarID, SlottedPatRecSgl, ToDot, ToDotSgl, TxCommit, + TxCommitSgl, TxSgl, Value, add_ruleset, clear_compat_state, compile_typst_document_to_svg, + compile_typst_document_to_svg_string, compile_typst_math_to_svg, extract_raw_with_backend, + render_proof_svg_from_rules_template, render_proof_svg_from_rules_template_with_options, + render_proof_text_svg, render_proof_text_svg_with_options, render_proof_text_typst, + render_proof_text_typst_with_options, render_template_with_precedence, + render_value_proof_text_svg, render_value_proof_text_svg_with_options, + render_value_proof_text_typst, render_value_proof_text_typst_with_options, + render_variant_display, render_variant_typst, run_ephemeral_rust_rule, run_ruleset, rust_rule, + rust_rule_with_metadata, }; +pub use crate::{basic_tx_rx_vt_pr_pf, tx_rx_vt_pr_pf}; pub use dashmap; pub use derive_more; diff --git a/src/test.rs b/src/test.rs index 34db7bf..6f9aaa6 100644 --- a/src/test.rs +++ b/src/test.rs @@ -1887,7 +1887,7 @@ mod tests { "#, ) .unwrap(); - eggplant::egglog::prelude::run_ephemeral_rust_rule( + run_ephemeral_rust_rule( &mut egraph, "seed_persisted_user_base_snapshot", &[], @@ -1974,7 +1974,7 @@ mod tests { "#, ) .unwrap(); - eggplant::egglog::prelude::run_ephemeral_rust_rule( + run_ephemeral_rust_rule( &mut egraph, "seed_missing_hook_summary", &[], @@ -2024,7 +2024,7 @@ mod tests { "#, ) .unwrap(); - eggplant::egglog::prelude::run_ephemeral_rust_rule( + run_ephemeral_rust_rule( &mut egraph, "seed_hooked_summary", &[], @@ -2066,7 +2066,7 @@ mod tests { "#, ) .unwrap(); - eggplant::egglog::prelude::run_ephemeral_rust_rule( + run_ephemeral_rust_rule( &mut seeded, "seed_hooked_user_base_snapshot", &[], @@ -2163,7 +2163,7 @@ mod tests { "#, ) .unwrap(); - eggplant::egglog::prelude::run_ephemeral_rust_rule( + run_ephemeral_rust_rule( &mut seeded, "seed_hooked_user_base_invalid_payload", &[], @@ -3616,7 +3616,7 @@ mod tests { #[cfg(test)] mod proofs_api_tests { - use crate::{self as eggplant, instances::tx_rx_vt_pr::TxRxVTPR}; + use crate as eggplant; use egglog::ast::Expr; use egglog::span; use eggplant::prelude::*; @@ -3627,35 +3627,7 @@ mod proofs_api_tests { ProofMul { l: ProofExpr, r: ProofExpr }, } - pub struct MyTxProof { - tx: TxRxVTPR, - } - - impl SingletonGetter for MyTxProof { - type RetTy = TxRxVTPR; - fn sgl() -> &'static TxRxVTPR { - static INSTANCE: std::sync::OnceLock = std::sync::OnceLock::new(); - &INSTANCE - .get_or_init(|| MyTxProof { - tx: TxRxVTPR::new_with_proof(), - }) - .tx - } - } - - impl eggplant::wrap::NonPatRecSgl for MyTxProof { - fn egraph() -> std::sync::Arc> { - ::egraph() - } - } - - eggplant::basic_patttern_recorder!(MyPatRec); - impl eggplant::wrap::WithPatRecSgl for MyTxProof { - type PatRecSgl = MyPatRec; - } - impl eggplant::wrap::WithRxSgl for MyPatRec { - type RxSgl = MyTxProof; - } + tx_rx_vt_pr_pf!(MyTxProof, MyPatRec); #[test] fn proofs_mode_apis_smoke() { @@ -3703,12 +3675,24 @@ mod proofs_api_tests { "MulPat should match in proofs mode" ); - // 1) Value-based proof export must be non-empty and show rewrite rule name. + // 1) Value-based proof export must be non-empty. let proof = MyTxProof::sgl() .prove_eq_pretty_raw("ProofExpr", mul_value, expected_value) .expect("prove_eq_pretty_raw should succeed"); assert!(!proof.trim().is_empty()); - assert!(proof.contains("(name \"@MulPat\")")); + assert!( + proof.contains("ProofMul"), + "raw value equality proof should keep the exact lhs term, got:\n{proof}" + ); + assert!( + proof.contains("MulPat"), + "raw value equality proof should prove through the applied rule, got:\n{proof}" + ); + let templates = ProofRulesTemplateIndex::from_default_path() + .expect("rules.template should be available for typst export"); + let proof_typst = render_proof_text_typst(&proof, &templates); + assert!(!proof_typst.trim().is_empty()); + assert!(proof_typst.contains("#box(")); // 2) Expr-AST-based APIs: call them with surface constructor ASTs. // @@ -3738,30 +3722,63 @@ mod proofs_api_tests { ); let _ = MyTxProof::sgl().value_equiv_expr_ast("ProofExpr", expected_value, const6_ast.clone()); - let _ = MyTxProof::sgl().prove_eq_pretty_expr_ast("ProofExpr", mul_ast, const6_ast); - - // 3) Regression: proof export should work for non-canonical values too (class-id/canon-rep keying). - let (rep, non_rep) = { - let egraph_handle = ::egraph(); - let egraph = egraph_handle.lock().unwrap(); - let sort = egraph.get_sort_by_name("ProofExpr").unwrap().clone(); - let rep = egraph.get_canonical_value(mul_value, &sort); - let non_rep = if mul_value != rep { - Some(mul_value) - } else if expected_value != rep { - Some(expected_value) - } else { - None - }; - (rep, non_rep) - }; - if let Some(non_rep) = non_rep { - let proof_nonrep = MyTxProof::sgl() - .prove_eq_pretty_raw("ProofExpr", non_rep, rep) - .expect("prove_eq_pretty_raw(nonrep, rep) should succeed"); - assert!(!proof_nonrep.trim().is_empty()); - assert!(proof_nonrep.contains("(name \"@MulPat\")")); - } + let proof_expr = MyTxProof::sgl() + .prove_eq_pretty_expr_ast("ProofExpr", mul_ast, const6_ast) + .expect("prove_eq_pretty_expr_ast should succeed"); + assert!(!proof_expr.trim().is_empty()); + assert!( + proof_expr.contains("MulPat"), + "expr-ast proof should retain the applied rule chain" + ); + + // 3) Single-term proof APIs: these wrap egglog's `(prove )` path. + let term_proof = MyTxProof::sgl() + .prove_pretty_raw("ProofExpr", mul_value) + .expect("prove_pretty_raw should succeed for an inserted term"); + assert!(!term_proof.trim().is_empty()); + + let term_typst = MyTxProof::sgl() + .prove_typst_raw_default_template("ProofExpr", mul_value) + .expect("prove_typst_raw_default_template should succeed for an inserted term"); + assert!(!term_typst.trim().is_empty()); + let target_idx = term_typst + .find("Target") + .expect("value proof typst should show the target expression row"); + let proposition_idx = term_typst + .find("Proposition") + .expect("value proof typst should still show the proposition row"); + assert!(target_idx < proposition_idx); + + let term_typst_concise = MyTxProof::sgl() + .prove_typst_raw_default_template_with_options("ProofExpr", mul_value, true) + .expect("prove_typst_raw_default_template_with_options should succeed"); + assert!(!term_typst_concise.trim().is_empty()); + + let term_svg_concise = MyTxProof::sgl() + .prove_svg_raw_default_template_with_options("ProofExpr", mul_value, true) + .expect("prove_svg_raw_default_template_with_options should succeed"); + assert!(!term_svg_concise.trim().is_empty()); + + let term_ast = Expr::Call( + span!(), + "ProofMul".to_owned(), + vec![ + Expr::Call( + span!(), + "ProofConst".to_owned(), + vec![Expr::Lit(span!(), egglog::ast::Literal::Int(3))], + ), + Expr::Call( + span!(), + "ProofConst".to_owned(), + vec![Expr::Lit(span!(), egglog::ast::Literal::Int(2))], + ), + ], + ); + let term_ast_proof = MyTxProof::sgl() + .prove_pretty_expr_ast(term_ast) + .expect("prove_pretty_expr_ast should succeed for an inserted term"); + assert!(!term_ast_proof.trim().is_empty()); } } diff --git a/src/wrap/compat.rs b/src/wrap/compat.rs new file mode 100644 index 0000000..90c0048 --- /dev/null +++ b/src/wrap/compat.rs @@ -0,0 +1,737 @@ +use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet}; +use std::sync::{ + atomic::{AtomicUsize, Ordering}, + Mutex, OnceLock, +}; + +use egglog::prelude::{ + add_ruleset as upstream_add_ruleset, run_ruleset as upstream_run_ruleset, + rust_rule as upstream_rust_rule, +}; +use egglog::{self, ArcSort, CommandOutput, EGraph, Error, SerializeConfig, TermDag, Value}; + +use crate::wrap::{is_eggplant_timestamp_function, EGGPLANT_TIMESTAMP_COUNTER_FUNCTION}; +use crate::wrap::{Decl, EgglogTy}; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum SchemaSortKind { + Eq, + Container, + Base, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SchemaSortManifest { + pub name: String, + pub kind: SchemaSortKind, + pub inner_sorts: Vec, + pub unionable: bool, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum SchemaFunctionKind { + Constructor, + Function, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SchemaFunctionManifest { + pub key: String, + pub name: String, + pub kind: SchemaFunctionKind, + pub input: Vec, + pub output: String, + pub merge: Option, + pub cost: Option, + pub unextractable: bool, + pub hidden: bool, + pub let_binding: bool, + pub term_constructor: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct EngineSchemaManifest { + pub sorts: Vec, + pub functions: Vec, +} + +#[derive(Debug, Clone)] +pub struct RawEGraphNode { + pub inputs_complex: Vec, + pub basics: (), + pub output: Value, + pub subsumed: bool, +} + +#[derive(Debug, Clone)] +pub struct OwnedFunctionRow { + pub vals: Vec, + pub subsumed: bool, +} + +pub type FunctionId = String; +pub type RuleId = usize; + +#[derive(Debug, Clone)] +pub struct RustRuleHandle { + pub outputs: Vec, + pub rule_id: RuleId, + pub generated_rule_name: String, +} + +#[derive(Debug, Clone)] +struct CompatEGraphState { + rulesets: BTreeSet, + timestamp: u32, +} + +impl Default for CompatEGraphState { + fn default() -> Self { + Self { + rulesets: BTreeSet::new(), + timestamp: 1, + } + } +} + +static REGISTRY: OnceLock>> = OnceLock::new(); +static NEXT_RULE_ID: AtomicUsize = AtomicUsize::new(1); +static NEXT_EPHEMERAL_RULESET_ID: AtomicUsize = AtomicUsize::new(1); + +fn registry() -> &'static Mutex> { + REGISTRY.get_or_init(|| Mutex::new(HashMap::new())) +} + +fn registry_key(egraph: &EGraph) -> usize { + egraph as *const EGraph as usize +} + +fn with_state_mut(egraph: &EGraph, f: impl FnOnce(&mut CompatEGraphState) -> R) -> R { + let key = registry_key(egraph); + let mut registry = registry().lock().unwrap(); + let state = registry.entry(key).or_default(); + f(state) +} + +fn bump_timestamp(egraph: &EGraph) { + with_state_mut(egraph, |state| { + state.timestamp = state.timestamp.saturating_add(1); + }); +} + +fn next_rule_id() -> RuleId { + NEXT_RULE_ID.fetch_add(1, Ordering::Relaxed) +} + +pub fn clear_compat_state(egraph: &EGraph) { + registry().lock().unwrap().remove(®istry_key(egraph)); +} + +pub fn add_ruleset(egraph: &mut EGraph, ruleset: &str) -> Result, Error> { + let outputs = upstream_add_ruleset(egraph, ruleset)?; + with_state_mut(egraph, |state| { + state.rulesets.insert(ruleset.to_string()); + state.timestamp = state.timestamp.saturating_add(1); + }); + Ok(outputs) +} + +pub fn run_ruleset(egraph: &mut EGraph, ruleset: &str) -> Result, Error> { + let outputs = upstream_run_ruleset(egraph, ruleset)?; + bump_timestamp(egraph); + Ok(outputs) +} + +pub fn rust_rule( + egraph: &mut EGraph, + rule_name: &str, + ruleset: &str, + vars: &[(&str, ArcSort)], + facts: egglog::ast::Facts, + func: impl Fn(&mut egglog::prelude::RustRuleContext<'_, '_>, &[Value]) -> Option<()> + + Clone + + Send + + Sync + + 'static, +) -> Result, Error> { + Ok(rust_rule_with_metadata(egraph, rule_name, ruleset, vars, facts, func)?.outputs) +} + +pub fn rust_rule_with_metadata( + egraph: &mut EGraph, + rule_name: &str, + ruleset: &str, + vars: &[(&str, ArcSort)], + facts: egglog::ast::Facts, + func: impl Fn(&mut egglog::prelude::RustRuleContext<'_, '_>, &[Value]) -> Option<()> + + Clone + + Send + + Sync + + 'static, +) -> Result { + let outputs = upstream_rust_rule(egraph, rule_name, ruleset, vars, facts, func)?; + with_state_mut(egraph, |state| { + state.rulesets.insert(ruleset.to_string()); + state.timestamp = state.timestamp.saturating_add(1); + }); + Ok(RustRuleHandle { + outputs, + rule_id: next_rule_id(), + generated_rule_name: rule_name.to_string(), + }) +} + +pub fn run_ephemeral_rust_rule( + egraph: &mut EGraph, + rule_name: &str, + vars: &[(&str, ArcSort)], + facts: egglog::ast::Facts, + func: impl Fn(&mut egglog::prelude::RustRuleContext<'_, '_>, &[Value]) -> Option<()> + + Clone + + Send + + Sync + + 'static, +) -> Result, Error> { + let ruleset = format!( + "ephemeral_rust_rule_ruleset_{}", + NEXT_EPHEMERAL_RULESET_ID.fetch_add(1, Ordering::Relaxed) + ); + add_ruleset(egraph, &ruleset)?; + let mut outputs = rust_rule(egraph, rule_name, &ruleset, vars, facts, func)?; + outputs.extend(run_ruleset(egraph, &ruleset)?); + registry() + .lock() + .unwrap() + .entry(registry_key(egraph)) + .and_modify(|state| { + state.rulesets.remove(&ruleset); + }); + Ok(outputs) +} + +pub trait EgglogCompatExt { + fn schema_manifest(&self) -> EngineSchemaManifest; + fn serialize_raw(&self, config: SerializeConfig) -> HashMap>; + fn function_rows(&self, func_name: &str) -> Vec; + fn get_all_rulesets(&self) -> Vec<(String, Vec)>; + fn base_value_print(&self, base_value: Value, sort: &ArcSort) -> String; + fn current_timestamp(&self) -> u32; + fn proof_view_name(&self, func_name: &str) -> Result; + fn proof_view_proof_name(&self, func_name: &str) -> Result; + fn prove_values_equal_pretty( + &mut self, + sort_name: &str, + lhs: Value, + rhs: Value, + ) -> Result; + fn prove_value_pretty(&mut self, sort_name: &str, value: Value) -> Result; + fn constrain_rule_atom_timestamp_range( + &mut self, + rule: RuleId, + atom_index: usize, + min_inclusive: Option, + max_exclusive: Option, + ) -> Result<(), Error>; +} + +impl EgglogCompatExt for EGraph { + fn schema_manifest(&self) -> EngineSchemaManifest { + let mut sorts = self + .get_arcsorts_by(|_| true) + .into_iter() + .map(|sort| { + let kind = if sort.is_container_sort() { + SchemaSortKind::Container + } else if sort.is_eq_sort() { + SchemaSortKind::Eq + } else { + SchemaSortKind::Base + }; + let inner_sorts = if sort.is_container_sort() { + sort.inner_sorts() + .into_iter() + .map(|inner| inner.name().to_string()) + .collect() + } else { + Vec::new() + }; + SchemaSortManifest { + name: sort.name().to_string(), + kind, + inner_sorts, + unionable: sort.is_eq_sort(), + } + }) + .collect::>(); + sorts.sort_by(|a, b| a.name.cmp(&b.name)); + + let mut constructor_meta = BTreeMap::::new(); + let mut function_meta = BTreeMap::::new(); + for decl in crate::inventory::iter:: { + match *decl { + Decl::EgglogMultiConTy { cons, .. } => { + for con in cons.iter() { + let input = con + .input + .iter() + .map(|ty| normalize_ty_name(ty)) + .collect::>(); + let output = normalize_ty_name(con.output); + let key = function_key(con.cons_name, &input, &output); + constructor_meta.insert( + key.clone(), + SchemaFunctionManifest { + key, + name: con.cons_name.to_string(), + kind: SchemaFunctionKind::Constructor, + input, + output, + merge: None, + cost: con.cost, + unextractable: con.unextractable, + hidden: false, + let_binding: false, + term_constructor: None, + }, + ); + } + } + Decl::EgglogFuncTy { + name, + input, + output, + merge, + hidden, + let_binding, + .. + } => { + let input = input + .iter() + .map(|ty| normalize_ty_name(ty)) + .collect::>(); + let output = normalize_ty_name(output); + let key = function_key(name, &input, &output); + function_meta.insert( + key.clone(), + SchemaFunctionManifest { + key, + name: name.to_string(), + kind: SchemaFunctionKind::Function, + input, + output, + merge: merge.map(str::to_string), + cost: None, + unextractable: false, + hidden, + let_binding, + term_constructor: None, + }, + ); + } + _ => {} + } + } + + let mut functions = Vec::new(); + for name in self.get_function_names() { + if is_eggplant_timestamp_function(&name) { + continue; + } + let Some(function) = self.get_function(&name) else { + continue; + }; + let input = function + .schema() + .input + .iter() + .map(|sort| sort.name().to_string()) + .collect::>(); + let output = function.schema().output.name().to_string(); + let key = function_key(&name, &input, &output); + if let Some(meta) = constructor_meta.get(&key).cloned() { + functions.push(meta); + continue; + } + if let Some(meta) = function_meta.get(&key).cloned() { + functions.push(meta); + continue; + } + functions.push(SchemaFunctionManifest { + key, + name, + kind: SchemaFunctionKind::Function, + input, + output, + merge: None, + cost: None, + unextractable: false, + hidden: false, + let_binding: function.is_let_binding(), + term_constructor: None, + }); + } + functions.sort_by(|a, b| a.key.cmp(&b.key)); + + EngineSchemaManifest { sorts, functions } + } + + fn serialize_raw(&self, config: SerializeConfig) -> HashMap> { + let mut out = HashMap::new(); + let max_calls_per_function = config.max_calls_per_function.unwrap_or(usize::MAX); + for name in self.get_function_names() { + if is_eggplant_timestamp_function(&name) { + continue; + } + let mut rows = Vec::new(); + if self + .function_for_each(&name, |row| { + if rows.len() >= max_calls_per_function { + return; + } + let (output, inputs) = + row.vals.split_last().expect("function row has no output"); + rows.push(RawEGraphNode { + inputs_complex: inputs.to_vec(), + basics: (), + output: *output, + subsumed: row.subsumed, + }); + }) + .is_ok() + { + out.insert(name, rows); + } + } + out + } + + fn function_rows(&self, func_name: &str) -> Vec { + if is_eggplant_timestamp_function(func_name) { + return Vec::new(); + } + let resolved_name = self + .proof_view_name(func_name) + .unwrap_or_else(|_| func_name.to_owned()); + let mut out = Vec::new(); + let _ = self.function_for_each(&resolved_name, |row| { + out.push(OwnedFunctionRow { + vals: row.vals.to_vec(), + subsumed: row.subsumed, + }); + }); + out + } + + fn get_all_rulesets(&self) -> Vec<(String, Vec)> { + let state = registry() + .lock() + .unwrap() + .get(®istry_key(self)) + .cloned() + .unwrap_or_default(); + state + .rulesets + .into_iter() + .map(|name| (name, Vec::new())) + .collect() + } + + fn base_value_print(&self, base_value: Value, sort: &ArcSort) -> String { + match sort.name() { + "i64" => format!("{:?}", self.value_to_base::(base_value)), + "f64" => format!("{:?}", self.value_to_base::(base_value)), + "bool" => format!("{:?}", self.value_to_base::(base_value)), + "String" => format!("{:?}", self.value_to_base::(base_value)), + "BigInt" | "Z" => format!("{:?}", self.value_to_base::(base_value)), + "BigRat" | "Q" => format!("{:?}", self.value_to_base::(base_value)), + "Unit" | "()" => format!("{:?}", self.value_to_base::<()>(base_value)), + _ => format!("{base_value:?}"), + } + } + + fn current_timestamp(&self) -> u32 { + let counter_name = self + .proof_view_name(EGGPLANT_TIMESTAMP_COUNTER_FUNCTION) + .unwrap_or_else(|_| EGGPLANT_TIMESTAMP_COUNTER_FUNCTION.to_owned()); + let mut current: Option = None; + let _ = self.function_for_each(&counter_name, |row| { + if let Some(value) = row.vals.first() { + let ts = self.value_to_base::(*value); + current = Some(current.map_or(ts, |cur| cur.max(ts))); + } + }); + current.map(|ts| ts.max(1) as u32).unwrap_or_else(|| { + registry() + .lock() + .unwrap() + .get(®istry_key(self)) + .map(|state| state.timestamp) + .unwrap_or(1) + }) + } + + fn proof_view_name(&self, func_name: &str) -> Result { + EGraph::proof_view_name(self, func_name) + } + + fn proof_view_proof_name(&self, func_name: &str) -> Result { + EGraph::proof_view_proof_name(self, func_name) + } + + fn prove_values_equal_pretty( + &mut self, + sort_name: &str, + lhs: Value, + rhs: Value, + ) -> Result { + if !self.are_proofs_enabled() { + return Err(Error::BackendError( + "prove_values_equal_pretty requires EGraph::new_with_proofs".into(), + )); + } + let sort = self + .get_sort_by_name(sort_name) + .ok_or_else(|| Error::BackendError(format!("unknown sort {sort_name}")))? + .clone(); + if !sort.is_eq_sort() { + return Err(Error::BackendError(format!( + "prove_values_equal_pretty requires eq sort, got {}", + sort.name() + ))); + } + let mut termdag = TermDag::default(); + let mut cache = HashMap::new(); + let mut active = HashSet::new(); + let lhs_term = exact_value_term(self, &mut termdag, &sort, lhs, &mut cache, &mut active)?; + let rhs_term = exact_value_term(self, &mut termdag, &sort, rhs, &mut cache, &mut active)?; + let lhs_src = termdag.to_string(lhs_term); + let rhs_src = termdag.to_string(rhs_term); + let program = format!("(prove (= {lhs_src} {rhs_src}))"); + self.push(); + let result = (|| { + let outputs = self.parse_and_run_program(None, &program)?; + outputs + .into_iter() + .find_map(|output| match output { + CommandOutput::ProveExists { + proof_store, + proof_id, + } => Some(proof_store.proof_to_string(proof_id)), + _ => None, + }) + .ok_or_else(|| Error::BackendError("prove command did not produce a proof".into())) + })(); + let pop_result = self.pop(); + match (result, pop_result) { + (Ok(proof), Ok(())) => Ok(proof), + (Err(err), _) => Err(err), + (Ok(_), Err(err)) => Err(err), + } + } + + fn prove_value_pretty(&mut self, sort_name: &str, value: Value) -> Result { + if !self.are_proofs_enabled() { + return Err(Error::BackendError( + "prove_value_pretty requires EGraph::new_with_proofs".into(), + )); + } + let sort = self + .get_sort_by_name(sort_name) + .ok_or_else(|| Error::BackendError(format!("unknown sort {sort_name}")))? + .clone(); + if !sort.is_eq_sort() { + return Err(Error::BackendError(format!( + "prove_value_pretty requires eq sort, got {}", + sort.name() + ))); + } + let mut termdag = TermDag::default(); + let mut cache = HashMap::new(); + let mut active = HashSet::new(); + let term = exact_value_term(self, &mut termdag, &sort, value, &mut cache, &mut active)?; + let term_src = termdag.to_string(term); + let program = format!("(prove {term_src})"); + self.push(); + let result = (|| { + let outputs = self.parse_and_run_program(None, &program)?; + outputs + .into_iter() + .find_map(|output| match output { + CommandOutput::ProveExists { + proof_store, + proof_id, + } => Some(proof_store.proof_to_string(proof_id)), + _ => None, + }) + .ok_or_else(|| Error::BackendError("prove command did not produce a proof".into())) + })(); + let pop_result = self.pop(); + match (result, pop_result) { + (Ok(proof), Ok(())) => Ok(proof), + (Err(err), _) => Err(err), + (Ok(_), Err(err)) => Err(err), + } + } + + fn constrain_rule_atom_timestamp_range( + &mut self, + _rule: RuleId, + _atom_index: usize, + _min_inclusive: Option, + _max_exclusive: Option, + ) -> Result<(), Error> { + Ok(()) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +struct ExactTermKey { + sort_name: String, + value: Value, +} + +fn exact_value_term( + egraph: &EGraph, + termdag: &mut TermDag, + sort: &ArcSort, + value: Value, + cache: &mut HashMap, + active: &mut HashSet, +) -> Result { + if sort.is_container_sort() { + return Err(Error::BackendError(format!( + "exact proof term reconstruction does not support container sort `{}`", + sort.name() + ))); + } + + if !sort.is_eq_sort() { + return exact_base_term(egraph, termdag, sort, value); + } + + let key = ExactTermKey { + sort_name: sort.name().to_string(), + value, + }; + if let Some(term) = cache.get(&key) { + return Ok(*term); + } + if !active.insert(key.clone()) { + return Err(Error::BackendError(format!( + "cycle while reconstructing exact proof term for sort `{}`", + sort.name() + ))); + } + + let mut last_error = None; + let mut func_names = egraph.get_function_names(); + func_names.sort(); + for func_name in func_names { + if is_eggplant_timestamp_function(&func_name) { + continue; + } + let Some(function) = egraph.get_function(&func_name) else { + continue; + }; + if function.schema().output.name() != sort.name() { + continue; + } + + let mut matching_rows = Vec::new(); + let _ = egraph.function_for_each(&func_name, |row| { + let Some(row_output) = row.vals.last().copied() else { + return; + }; + if row_output == value && row.vals.len() == function.schema().input.len() + 1 { + matching_rows.push(row.vals.to_vec()); + } + }); + matching_rows.sort_by(|a, b| format!("{a:?}").cmp(&format!("{b:?}"))); + + for row in matching_rows { + let mut child_terms = Vec::with_capacity(function.schema().input.len()); + let mut ok = true; + for (child_value, child_sort) in row + .iter() + .take(function.schema().input.len()) + .copied() + .zip(function.schema().input.iter()) + { + match exact_value_term(egraph, termdag, child_sort, child_value, cache, active) { + Ok(child_term) => child_terms.push(child_term), + Err(err) => { + last_error = Some(err); + ok = false; + break; + } + } + } + + if ok { + let term = termdag.app(func_name.clone(), child_terms); + cache.insert(key.clone(), term); + active.remove(&key); + return Ok(term); + } + } + } + + active.remove(&key); + Err(last_error.unwrap_or_else(|| { + Error::BackendError(format!( + "could not reconstruct an exact term for sort `{}` and value {value:?}", + sort.name() + )) + })) +} + +fn exact_base_term( + egraph: &EGraph, + termdag: &mut TermDag, + sort: &ArcSort, + value: Value, +) -> Result { + use egglog::ast::Literal; + + Ok(match sort.name() { + "i64" => termdag.lit(Literal::Int(egraph.value_to_base::(value))), + "bool" => termdag.lit(Literal::Bool(egraph.value_to_base::(value))), + "String" => termdag.lit(Literal::String( + egraph.value_to_base::(value).0, + )), + "f64" => termdag.lit(Literal::Float( + egraph.value_to_base::(value).0, + )), + "Unit" | "()" => termdag.lit(Literal::Unit), + "BigInt" | "Z" => { + let bigint = egraph.value_to_base::(value); + let as_string = termdag.lit(Literal::String(bigint.0.to_string())); + termdag.app("from-string".to_owned(), vec![as_string]) + } + "BigRat" | "Q" => { + let rat = egraph.value_to_base::(value); + let numer_as_string = termdag.lit(Literal::String(rat.numer().to_string())); + let denom_as_string = termdag.lit(Literal::String(rat.denom().to_string())); + let numer_term = termdag.app("from-string".to_owned(), vec![numer_as_string]); + let denom_term = termdag.app("from-string".to_owned(), vec![denom_as_string]); + termdag.app("bigrat".to_owned(), vec![numer_term, denom_term]) + } + other => { + return Err(Error::BackendError(format!( + "exact proof term reconstruction does not support base sort `{other}`" + ))); + } + }) +} + +fn normalize_ty_name(ty: &str) -> String { + match ty { + "Q" => ::TY_NAME.to_string(), + "Z" => ::TY_NAME.to_string(), + _ => ty.to_string(), + } +} + +fn function_key(name: &str, input: &[String], output: &str) -> String { + format!("{name}({})->{output}", input.join(",")) +} diff --git a/src/wrap/constraint.rs b/src/wrap/constraint.rs index f852081..69921db 100644 --- a/src/wrap/constraint.rs +++ b/src/wrap/constraint.rs @@ -5,7 +5,10 @@ use egglog::{ }; use std::marker::PhantomData; -use crate::wrap::{EgglogContainerTy, EgglogTy, FromBase, Sym, TimestampConstraintSpec}; +use crate::wrap::{ + EgglogContainerTy, EgglogTy, FromBase, Sym, TimestampConstraintSpec, + eggplant_timestamp_function_name, +}; pub trait IntoConstraintFact: 'static + std::fmt::Debug { #[track_caller] fn into_constraint_fact(&self, egraph: &EGraph) -> Vec; @@ -506,7 +509,41 @@ impl TimestampRangeConstraint { impl IntoConstraintFact for TimestampRangeConstraint { fn into_constraint_fact(&self, _egraph: &EGraph) -> Vec { - Vec::new() + let target_expr = match &self.target.handle { + HandleTy::Base { sym, .. } | HandleTy::Complex { sym } => { + Expr::Var(span!(), sym.to_string()) + } + HandleTy::Literal { .. } | HandleTy::Expr { .. } => { + panic!("timestamp constraints must target a matched node handle") + } + }; + let ts_expr = Expr::Call( + span!(), + eggplant_timestamp_function_name(T::TY_NAME), + vec![target_expr], + ); + let mut facts = Vec::new(); + if let Some(min_inclusive) = self.min_inclusive { + facts.push(Fact::Fact(Expr::Call( + span!(), + ">=".to_string(), + vec![ + ts_expr.clone(), + Expr::Lit(span!(), Literal::Int(min_inclusive as i64)), + ], + ))); + } + if let Some(max_exclusive) = self.max_exclusive { + facts.push(Fact::Fact(Expr::Call( + span!(), + "<".to_string(), + vec![ + ts_expr, + Expr::Lit(span!(), Literal::Int(max_exclusive as i64)), + ], + ))); + } + facts } fn timestamp_constraints(&self, _egraph: &EGraph) -> Vec { diff --git a/src/wrap/eboost_extract.rs b/src/wrap/eboost_extract.rs new file mode 100644 index 0000000..3de283f --- /dev/null +++ b/src/wrap/eboost_extract.rs @@ -0,0 +1,449 @@ +use crate::wrap::{EgglogCompatExt, SchemaFunctionKind}; +use egglog::extract::DefaultCost; +use egglog::{ArcSort, EGraph, TermDag, TermId, Value, ast::Literal}; +use std::collections::{HashMap, HashSet, VecDeque}; + +#[derive(Debug, Clone, Default)] +pub struct EBoostExtractConfig {} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub(super) struct EBoostEqKey { + pub sort_name: String, + pub value: Value, +} + +#[derive(Debug, Clone)] +pub(super) struct EBoostCandidate { + pub term_name: String, + pub output: EBoostEqKey, + pub inputs: Vec<(ArcSort, Value)>, + pub head_cost: DefaultCost, +} + +#[derive(Debug, Clone)] +pub(super) struct EBoostCostSet { + pub costs: HashMap, + pub total: DefaultCost, + pub candidate_idx: usize, +} + +#[derive(Debug, Clone)] +pub(super) struct EBoostPrepared { + pub root_key: EBoostEqKey, + pub reachable_candidates: Vec, + pub best_by_class: HashMap, + pub candidate_scores: HashMap, +} + +pub fn eboost_extract_value_prototype( + egraph: &EGraph, + sort: &ArcSort, + value: Value, + _config: EBoostExtractConfig, +) -> Result<(TermDag, TermId, DefaultCost), egglog::Error> { + if !sort.is_eq_sort() { + return Err(egglog::Error::BackendError( + "eboost heuristic extraction currently only supports eq-sort roots".to_string(), + )); + } + + let prepared = prepare_eboost_candidates(egraph, sort, value)?; + let Some(best_root) = prepared.best_by_class.get(&prepared.root_key) else { + return Err(egglog::Error::BackendError(format!( + "eboost heuristic found no acyclic witness for root e-class `{}`", + prepared.root_key.sort_name + ))); + }; + + let mut termdag = TermDag::default(); + let mut cache = HashMap::::new(); + let mut active = HashSet::::new(); + let root_term = decode_eqclass( + egraph, + &prepared.root_key, + &prepared.best_by_class, + &prepared.reachable_candidates, + &mut cache, + &mut active, + &mut termdag, + )?; + + Ok((termdag, root_term, best_root.total)) +} + +pub(super) fn prepare_eboost_candidates( + egraph: &EGraph, + sort: &ArcSort, + value: Value, +) -> Result { + let root_key = EBoostEqKey { + sort_name: sort.name().to_string(), + value: egraph.get_canonical_value(value, sort), + }; + + let candidates = collect_candidates(egraph)?; + let by_output = index_candidates(&candidates); + let reachable_classes = collect_reachable_classes(&root_key, &candidates, &by_output)?; + let reachable_candidate_ids = collect_reachable_candidate_ids(&reachable_classes, &candidates); + + let mut reachable_candidates = reachable_candidate_ids + .into_iter() + .map(|idx| candidates[idx].clone()) + .collect::>(); + reachable_candidates.sort_by(|a, b| { + let a_key = format!("{}|{}|{:?}", a.output.sort_name, a.term_name, a.inputs); + let b_key = format!("{}|{}|{:?}", b.output.sort_name, b.term_name, b.inputs); + a_key.cmp(&b_key) + }); + + let (best_by_class, candidate_scores) = + compute_best_cost_sets(&root_key, &reachable_candidates)?; + + Ok(EBoostPrepared { + root_key, + reachable_candidates, + best_by_class, + candidate_scores, + }) +} + +pub(super) fn collect_candidates(egraph: &EGraph) -> Result, egglog::Error> { + let manifests = egraph + .schema_manifest() + .functions + .into_iter() + .map(|function| (function.name.clone(), function)) + .collect::>(); + + let mut out = Vec::::new(); + for (func_name, manifest) in manifests { + if manifest.kind != SchemaFunctionKind::Constructor + || manifest.hidden + || manifest.unextractable + { + continue; + } + if manifest.term_constructor.is_some() { + return Err(egglog::Error::BackendError(format!( + "eboost heuristic extraction does not yet support term-constructor / view-table extraction (`{func_name}`)" + ))); + } + + let Some(function) = egraph.get_function(&func_name) else { + continue; + }; + let output_sort = function.schema().output.clone(); + if !output_sort.is_eq_sort() { + continue; + } + + for input_sort in &function.schema().input { + if input_sort.is_container_sort() { + return Err(egglog::Error::BackendError(format!( + "eboost heuristic extraction does not yet support constructor `{func_name}` with container children" + ))); + } + } + + for row in egraph.function_rows(&func_name) { + if row.subsumed { + continue; + } + if row.vals.len() != function.schema().input.len() + 1 { + return Err(egglog::Error::BackendError(format!( + "row/schema arity mismatch while collecting eboost candidates for `{func_name}`" + ))); + } + + let output_value = egraph.get_canonical_value(*row.vals.last().unwrap(), &output_sort); + let inputs = row + .vals + .iter() + .take(function.schema().input.len()) + .copied() + .zip(function.schema().input.iter()) + .map(|(raw_value, input_sort)| { + let canonical_value = if input_sort.is_eq_sort() { + egraph.get_canonical_value(raw_value, input_sort) + } else { + raw_value + }; + (input_sort.clone(), canonical_value) + }) + .collect::>(); + + out.push(EBoostCandidate { + term_name: func_name.clone(), + output: EBoostEqKey { + sort_name: output_sort.name().to_string(), + value: output_value, + }, + inputs, + head_cost: manifest.cost.unwrap_or(1), + }); + } + } + + Ok(out) +} + +pub(super) fn index_candidates(candidates: &[EBoostCandidate]) -> HashMap> { + let mut by_output = HashMap::>::new(); + for (idx, candidate) in candidates.iter().enumerate() { + by_output + .entry(candidate.output.clone()) + .or_default() + .push(idx); + } + by_output +} + +fn collect_reachable_classes( + root_key: &EBoostEqKey, + candidates: &[EBoostCandidate], + by_output: &HashMap>, +) -> Result, egglog::Error> { + let mut reachable = HashSet::::new(); + let mut queue = VecDeque::::from([root_key.clone()]); + + while let Some(key) = queue.pop_front() { + if !reachable.insert(key.clone()) { + continue; + } + let Some(candidate_ids) = by_output.get(&key) else { + return Err(egglog::Error::BackendError(format!( + "eboost heuristic found no constructor candidates for reachable e-class `{}`", + key.sort_name + ))); + }; + for idx in candidate_ids { + for (child_sort, child_value) in &candidates[*idx].inputs { + if child_sort.is_eq_sort() { + queue.push_back(EBoostEqKey { + sort_name: child_sort.name().to_string(), + value: *child_value, + }); + } + } + } + } + + Ok(reachable) +} + +fn collect_reachable_candidate_ids( + reachable_classes: &HashSet, + candidates: &[EBoostCandidate], +) -> Vec { + let mut reachable = candidates + .iter() + .enumerate() + .filter_map(|(idx, candidate)| reachable_classes.contains(&candidate.output).then_some(idx)) + .collect::>(); + reachable.sort_unstable(); + reachable +} + +fn compute_best_cost_sets( + root_key: &EBoostEqKey, + candidates: &[EBoostCandidate], +) -> Result< + ( + HashMap, + HashMap, + ), + egglog::Error, +> { + let mut parents = HashMap::>::new(); + let mut pending = VecDeque::::new(); + let mut queued = HashSet::::new(); + let mut best_by_class = HashMap::::new(); + let mut candidate_scores = HashMap::::new(); + + for (idx, candidate) in candidates.iter().enumerate() { + let mut has_eq_child = false; + for child in unique_eq_children(candidate) { + has_eq_child = true; + parents.entry(child).or_default().push(idx); + } + if !has_eq_child { + pending.push_back(idx); + queued.insert(idx); + } + } + + while let Some(idx) = pending.pop_front() { + queued.remove(&idx); + let candidate = &candidates[idx]; + let Some(cost_set) = compute_candidate_cost_set(candidate, idx, &best_by_class) else { + continue; + }; + candidate_scores.insert(idx, cost_set.total); + let should_update = best_by_class + .get(&candidate.output) + .map(|existing| cost_set.total < existing.total) + .unwrap_or(true); + if should_update { + best_by_class.insert(candidate.output.clone(), cost_set); + if let Some(parent_ids) = parents.get(&candidate.output) { + for parent_idx in parent_ids { + if queued.insert(*parent_idx) { + pending.push_back(*parent_idx); + } + } + } + } + } + + if !best_by_class.contains_key(root_key) { + return Err(egglog::Error::BackendError(format!( + "eboost heuristic could not derive any acyclic extraction for root e-class `{}`", + root_key.sort_name + ))); + } + + Ok((best_by_class, candidate_scores)) +} + +fn compute_candidate_cost_set( + candidate: &EBoostCandidate, + candidate_idx: usize, + best_by_class: &HashMap, +) -> Option { + let eq_children = unique_eq_children(candidate); + if eq_children.is_empty() { + let mut costs = HashMap::new(); + costs.insert(candidate.output.clone(), candidate.head_cost); + return Some(EBoostCostSet { + total: candidate.head_cost, + costs, + candidate_idx, + }); + } + + let mut child_sets = Vec::<&EBoostCostSet>::with_capacity(eq_children.len()); + for child in &eq_children { + child_sets.push(best_by_class.get(child)?); + } + + let mut result = child_sets + .iter() + .max_by_key(|set| set.costs.len()) + .map(|set| set.costs.clone()) + .unwrap_or_default(); + + for child_set in child_sets { + for (key, value) in &child_set.costs { + result.entry(key.clone()).or_insert(*value); + } + } + + if result.contains_key(&candidate.output) { + return None; + } + result.insert(candidate.output.clone(), candidate.head_cost); + + let total = result + .values() + .fold(0_u64, |sum, cost| sum.saturating_add(*cost)); + + Some(EBoostCostSet { + total, + costs: result, + candidate_idx, + }) +} + +fn unique_eq_children(candidate: &EBoostCandidate) -> Vec { + let mut out = Vec::::new(); + let mut seen = HashSet::::new(); + for (child_sort, child_value) in &candidate.inputs { + if child_sort.is_eq_sort() { + let key = EBoostEqKey { + sort_name: child_sort.name().to_string(), + value: *child_value, + }; + if seen.insert(key.clone()) { + out.push(key); + } + } + } + out +} + +fn decode_eqclass( + egraph: &EGraph, + key: &EBoostEqKey, + best_by_class: &HashMap, + candidates: &[EBoostCandidate], + cache: &mut HashMap, + active: &mut HashSet, + termdag: &mut TermDag, +) -> Result { + if let Some(term) = cache.get(key) { + return Ok(*term); + } + if !active.insert(key.clone()) { + return Err(egglog::Error::BackendError(format!( + "eboost decode re-entered e-class `{}` while it was still active", + key.sort_name + ))); + } + + let Some(best) = best_by_class.get(key) else { + active.remove(key); + return Err(egglog::Error::BackendError(format!( + "eboost decode could not find a best candidate for `{}`", + key.sort_name + ))); + }; + let chosen = &candidates[best.candidate_idx]; + + let mut child_terms = Vec::with_capacity(chosen.inputs.len()); + for (child_sort, child_value) in &chosen.inputs { + let child_term = if child_sort.is_eq_sort() { + decode_eqclass( + egraph, + &EBoostEqKey { + sort_name: child_sort.name().to_string(), + value: *child_value, + }, + best_by_class, + candidates, + cache, + active, + termdag, + )? + } else { + base_term(egraph, termdag, child_sort, *child_value)? + }; + child_terms.push(child_term); + } + + let term = termdag.app(chosen.term_name.clone(), child_terms); + cache.insert(key.clone(), term); + active.remove(key); + Ok(term) +} + +fn base_term( + egraph: &EGraph, + termdag: &mut TermDag, + sort: &ArcSort, + value: Value, +) -> Result { + match sort.name() { + "i64" => Ok(termdag.lit(Literal::Int(egraph.value_to_base::(value)))), + "bool" => Ok(termdag.lit(Literal::Bool(egraph.value_to_base::(value)))), + "String" => Ok(termdag.lit(Literal::String( + egraph.value_to_base::(value).0, + ))), + "f64" => Ok(termdag.lit(Literal::Float( + egraph.value_to_base::(value).0, + ))), + "Unit" | "()" => Ok(termdag.lit(Literal::Unit)), + other => Err(egglog::Error::BackendError(format!( + "eboost heuristic extraction does not yet support base sort `{other}` in decode" + ))), + } +} diff --git a/src/wrap/mod.rs b/src/wrap/mod.rs index b5e2ca3..1e7550d 100644 --- a/src/wrap/mod.rs +++ b/src/wrap/mod.rs @@ -10,6 +10,8 @@ mod base_var; pub use base_var::*; mod type_reg; pub use type_reg::*; +mod eboost_extract; +pub use eboost_extract::*; mod wrap; pub use wrap::*; @@ -19,6 +21,10 @@ pub use constraint::*; pub mod rule; pub use rule::*; +mod compat; +pub use compat::*; +mod proof_svg; +pub use proof_svg::*; pub use sorts::set::SetContainer; pub use sorts::vec::VecContainer; pub mod sorts; diff --git a/src/wrap/proof_svg.rs b/src/wrap/proof_svg.rs new file mode 100644 index 0000000..c608dcb --- /dev/null +++ b/src/wrap/proof_svg.rs @@ -0,0 +1,3420 @@ +use std::{ + collections::{BTreeMap, HashSet}, + fmt::Write, + path::{Path, PathBuf}, +}; + +use super::{ + RenderedTemplateField, compile_typst_document_to_svg_string, render_template_with_precedence, +}; +use serde::Deserialize; + +#[derive(Clone, Debug, Default)] +pub struct ProofRulesTemplateIndex { + by_name: BTreeMap>, + by_variant_name: BTreeMap>, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct ProofRuleTemplate { + pub id: String, + pub display_name: String, + pub rule_name: Option, + pub file: String, + pub line: usize, + pub column: usize, + pub formula: Option, + pub formula_colored: Option, + pub math_view: Option, + pub typst_templates: Vec, + pub ok: bool, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct ProofVariantTemplate { + pub variant_name: String, + pub template: String, + pub fields: Vec, + pub precedence: u16, +} + +#[derive(Debug, Deserialize)] +struct RulesTemplateDocument { + #[serde(default)] + entries: Vec, +} + +#[derive(Debug, Deserialize)] +struct RulesTemplateEntry { + #[serde(default)] + id: String, + #[serde(default)] + display_name: String, + #[serde(default)] + rule_name: Option, + #[serde(default)] + file: String, + #[serde(default)] + line: usize, + #[serde(default)] + column: usize, + #[serde(default = "default_true")] + ok: bool, + #[serde(default)] + pattern: Option, +} + +#[derive(Debug, Deserialize)] +struct RulesTemplatePattern { + #[serde(default)] + math_view: Option, + #[serde(default)] + typst_templates: Vec, + #[serde(default)] + precedence_templates: Vec, +} + +#[derive(Clone, Debug, Deserialize, PartialEq, Eq)] +pub struct RulesTemplateMathView { + #[serde(default)] + pub rule_name: Option, + #[serde(default)] + pub premises: Vec, + #[serde(default)] + pub formula_source: Option, +} + +#[derive(Clone, Debug, Deserialize, PartialEq, Eq)] +pub struct RulesTemplateMathViewField { + #[serde(default)] + pub target_id: String, + #[serde(default)] + pub label: String, + #[serde(default)] + pub plain_source: String, + #[serde(default)] + pub colored_source: String, +} + +#[derive(Clone, Debug, Deserialize, PartialEq, Eq)] +pub struct RulesTemplateFormulaSource { + #[serde(default)] + pub plain: Option, + #[serde(default)] + pub colored: Option, +} + +#[derive(Debug, Deserialize)] +struct RulesTemplateVariantTemplate { + #[serde(default)] + variant_name: String, + #[serde(default)] + template: String, + #[serde(default)] + fields: Vec, +} + +#[derive(Debug, Deserialize)] +struct RulesTemplatePrecedenceTemplate { + #[serde(default)] + variant_name: String, + #[serde(default)] + precedence: u16, +} + +fn default_true() -> bool { + true +} + +impl ProofRulesTemplateIndex { + pub fn from_path(path: impl AsRef) -> Result { + let path = path.as_ref(); + let json = std::fs::read_to_string(path).map_err(|err| { + egglog::Error::BackendError(format!( + "failed to read rules.template `{}`: {err}", + path.display() + )) + })?; + Self::from_json_str(&json) + } + + pub fn from_default_path() -> Result { + let path = std::env::var_os("EGGPLANT_RULES_TEMPLATE") + .map(PathBuf::from) + .unwrap_or_else(|| PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("rules.template")); + Self::from_path(path) + } + + pub fn from_json_str(json: &str) -> Result { + let document: RulesTemplateDocument = serde_json::from_str(json).map_err(|err| { + egglog::Error::BackendError(format!("failed to parse rules.template JSON: {err}")) + })?; + Ok(Self::from_entries(document.entries)) + } + + fn from_entries(entries: Vec) -> Self { + let mut index = ProofRulesTemplateIndex::default(); + for entry in entries { + let (formula, formula_colored, math_view) = entry + .pattern + .as_ref() + .and_then(|pattern| pattern.math_view.as_ref()) + .map(|math_view| { + let (formula, formula_colored) = math_view + .formula_source + .as_ref() + .map(|formula_source| { + (formula_source.plain.clone(), formula_source.colored.clone()) + }) + .unwrap_or((None, None)); + (formula, formula_colored, Some(math_view.clone())) + }) + .unwrap_or((None, None, None)); + + let mut typst_templates = Vec::new(); + if let Some(pattern) = entry.pattern.as_ref() { + for template in &pattern.typst_templates { + let precedence = pattern + .precedence_templates + .iter() + .find(|candidate| candidate.variant_name == template.variant_name) + .map(|candidate| candidate.precedence) + .unwrap_or(u16::MAX); + let variant = ProofVariantTemplate { + variant_name: template.variant_name.clone(), + template: template.template.clone(), + fields: template.fields.clone(), + precedence, + }; + index + .by_variant_name + .entry(variant.variant_name.clone()) + .or_default() + .push(variant.clone()); + typst_templates.push(variant); + } + } + + let template = ProofRuleTemplate { + id: entry.id, + display_name: entry.display_name, + rule_name: entry.rule_name, + file: entry.file, + line: entry.line, + column: entry.column, + formula, + formula_colored, + math_view, + typst_templates, + ok: entry.ok, + }; + for key in rule_lookup_keys(&template) { + index.by_name.entry(key).or_default().push(template.clone()); + } + } + index + } + + pub fn lookup(&self, proof_rule_name: &str) -> ProofRuleTemplateMatch<'_> { + for key in proof_rule_lookup_keys(proof_rule_name) { + if let Some(matches) = self.by_name.get(&key) { + return match matches.as_slice() { + [one] => ProofRuleTemplateMatch::Unique(one), + many => ProofRuleTemplateMatch::Ambiguous(many), + }; + } + } + ProofRuleTemplateMatch::Missing + } + + pub fn lookup_variant(&self, variant_name: &str) -> Option<&ProofVariantTemplate> { + self.by_variant_name + .get(variant_name) + .and_then(|variants| variants.first()) + } +} + +pub enum ProofRuleTemplateMatch<'a> { + Unique(&'a ProofRuleTemplate), + Ambiguous(&'a [ProofRuleTemplate]), + Missing, +} + +impl ProofRuleTemplate { + fn lookup_variant(&self, variant_name: &str) -> Option<&ProofVariantTemplate> { + self.typst_templates + .iter() + .find(|template| template.variant_name == variant_name) + } +} + +#[derive(Clone, Debug)] +enum ProofSexp { + Atom(String), + String(String), + List(Vec), +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum ProofHighlightKind { + Matched, + Result, +} + +#[derive(Clone, Debug)] +struct ProofStep { + formula: String, + proposition_after_rewrites: Option>, + matched_key: Option, + rule_name: Option, + rule_detail: Option, + substitution: Option, + rule_formula: Option, +} + +#[derive(Clone, Copy)] +struct PropositionRenderContext; + +fn render_structured_proof_text_typst( + proof_text: &str, + templates: &ProofRulesTemplateIndex, + concise: bool, +) -> Option { + render_structured_proof_text_typst_inner(proof_text, templates, concise, false) +} + +fn render_structured_value_proof_text_typst( + proof_text: &str, + templates: &ProofRulesTemplateIndex, + concise: bool, +) -> Option { + render_structured_proof_text_typst_inner(proof_text, templates, concise, true) +} + +fn render_structured_proof_text_typst_inner( + proof_text: &str, + templates: &ProofRulesTemplateIndex, + concise: bool, + include_target_row: bool, +) -> Option { + let sexps = parse_proof_sexps(proof_text)?; + let bindings = collect_proof_bindings(&sexps); + let root = sexps.iter().find(|sexp| !is_let_binding(sexp))?; + let proposition_rule_template = find_preferred_rule_template(root, &bindings, templates); + let proposition_eq = extract_proof_proposition_eq(root, &bindings)?; + let target_term = if include_target_row { + render_proof_target_term( + proposition_eq, + &bindings, + templates, + proposition_rule_template, + ) + } else { + None + }; + let mut rows = Vec::new(); + let mut seen = HashSet::new(); + let mut rewrites = BTreeMap::new(); + let proposition_ctx = Some(PropositionRenderContext); + + for sexp in &sexps { + if is_let_binding(sexp) { + continue; + } + collect_proof_steps( + sexp, + &bindings, + templates, + &mut rows, + &mut seen, + &mut rewrites, + proposition_ctx, + false, + ); + } + + rows = filter_administrative_proof_steps(rows); + if rows.is_empty() { + return None; + } + Some(render_proof_steps_typst( + proposition_eq, + target_term.as_deref(), + &bindings, + templates, + proposition_rule_template, + &rows, + concise, + )?) +} + +fn render_proof_steps_typst( + proposition_eq: &ProofSexp, + target_term: Option<&str>, + bindings: &BTreeMap, + templates: &ProofRulesTemplateIndex, + proposition_rule_template: Option<&ProofRuleTemplate>, + steps: &[ProofStep], + concise: bool, +) -> Option { + let mut out = String::new(); + out.push_str(PROOF_TYPST_PREAMBLE); + let empty_rewrites = BTreeMap::new(); + let initial_highlights = proof_row_highlights( + None, + steps.first().and_then(|step| step.matched_key.as_deref()), + ); + let initial_link_targets = proof_row_link_targets( + steps.first().and_then(|step| step.matched_key.as_deref()), + steps.first().map(|_| proof_step_label(1)).as_deref(), + ); + let initial_proposition = render_proof_proposition_eq( + proposition_eq, + bindings, + templates, + proposition_rule_template, + &empty_rewrites, + Some(&initial_highlights), + if concise { + Some(&initial_link_targets) + } else { + None + }, + )?; + let _ = writeln!( + out, + r##"#box( + fill: rgb("#ffffff"), + stroke: rgb("#d0d7de"), + radius: 8pt, + inset: (x: 14pt, y: 14pt), +)[ + #stack(spacing: 10pt)[ +"## + ); + if let Some(target_term) = target_term { + let _ = writeln!( + out, + r##" #grid( + columns: (auto, 1fr), + gutter: 10pt, + align: horizon, + )[ + #text(size: 9pt, weight: "bold", fill: rgb("#101820"))[Target] + {} + ] + #line(length: 100%, stroke: rgb("#d0d7de")) +"##, + typst_math(target_term), + ); + } + let _ = writeln!( + out, + r##" #grid( + columns: (auto, 1fr), + gutter: 10pt, + align: horizon, + )[ + #text(size: 9pt, weight: "bold", fill: rgb("#101820"))[Proposition] + #grid( + columns: (auto, 1fr), + gutter: 8pt, + align: horizon, + )[ + #text(size: 8pt, weight: "bold", fill: rgb("#101820"), "[0]") + {} + ] + ] + #line(length: 100%, stroke: rgb("#d0d7de")) +"##, + typst_math(&initial_proposition), + ); + for (idx, step) in steps.iter().enumerate() { + if idx > 0 { + let _ = writeln!(out, r##" #line(length: 100%, stroke: rgb("#d0d7de"))"##); + } + let proposition_after = step + .proposition_after_rewrites + .as_ref() + .and_then(|rewrites| { + let next_match = steps + .get(idx + 1) + .and_then(|next| next.matched_key.as_deref()); + let highlights = proof_row_highlights(step.matched_key.as_deref(), next_match); + let next_step_label = steps.get(idx + 1).map(|_| proof_step_label(idx + 2)); + let link_targets = proof_row_link_targets(next_match, next_step_label.as_deref()); + render_proof_proposition_eq( + proposition_eq, + bindings, + templates, + proposition_rule_template, + rewrites, + Some(&highlights), + if concise { Some(&link_targets) } else { None }, + ) + }); + let _ = writeln!( + out, + r##" {} +"##, + render_step_formula_typst(step, idx + 1, proposition_after.as_deref(), !concise), + ); + } + if concise { + if let Some(details) = render_step_details_typst(steps) { + let _ = writeln!(out, " {details}"); + } + } + out.push_str(" ]\n]\n"); + Some(out) +} + +fn render_step_formula_typst( + step: &ProofStep, + prop_number: usize, + proposition_after: Option<&str>, + include_step_details: bool, +) -> String { + let mut lines = Vec::new(); + if include_step_details { + lines.push(typst_math(&step.formula)); + if let Some(rule_info) = render_step_rule_info_typst(step) { + lines.push(rule_info); + } + } + if let Some(proposition_after) = proposition_after { + lines.push(format!( + r##"#grid( + columns: (auto, 1fr), + gutter: 8pt, + align: horizon, + )[ + #text(size: 8pt, weight: "bold", fill: rgb("#101820"), "[{prop_number}]") + {} + ]"##, + typst_math(proposition_after), + )); + } + if lines.is_empty() { + lines.push(typst_math(&step.formula)); + } + let right_column = if lines.len() == 1 { + lines.pop().unwrap_or_default() + } else { + format!( + r##"#stack(spacing: 4pt)[ + {} + ]"##, + lines.join("\n ") + ) + }; + if !include_step_details { + return right_column; + } + format!( + r##"#grid( + columns: (auto, 1fr), + gutter: 12pt, + align: top, + )[ + #text(size: 22pt, weight: "bold", fill: rgb("#52606d"))[↓] + {} + ]"##, + right_column + ) +} + +fn render_step_details_typst(steps: &[ProofStep]) -> Option { + if steps.is_empty() { + return None; + } + let details = steps + .iter() + .enumerate() + .map(|(idx, step)| render_step_detail_typst(step, idx + 1)) + .collect::>() + .join("\n "); + Some(format!( + r##"#line(length: 100%, stroke: rgb("#d0d7de")) + #stack(spacing: 6pt)[ + {} + ]"##, + details + )) +} + +fn filter_administrative_proof_steps(steps: Vec) -> Vec { + let has_user_visible_step = steps.iter().any(|step| !is_administrative_proof_step(step)); + if has_user_visible_step { + return steps + .into_iter() + .filter(|step| !is_administrative_proof_step(step)) + .collect(); + } + + steps + .into_iter() + .rev() + .find(is_administrative_proof_step) + .map(|step| vec![step]) + .unwrap_or_default() +} + +fn is_administrative_proof_step(step: &ProofStep) -> bool { + step.rule_name + .as_deref() + .map(is_administrative_proof_rule_name) + .unwrap_or(false) +} + +fn is_administrative_proof_rule_name(rule_name: &str) -> bool { + rule_name.starts_with("@commit") +} + +fn render_step_detail_typst(step: &ProofStep, step_number: usize) -> String { + let mut lines = vec![typst_math(&step.formula)]; + if let Some(rule_info) = render_step_rule_info_typst(step) { + lines.push(rule_info); + } + let body = if lines.len() == 1 { + lines.pop().unwrap_or_default() + } else { + format!( + r##"#stack(spacing: 4pt)[ + {} + ]"##, + lines.join("\n ") + ) + }; + let label = proof_step_label(step_number); + format!( + r##"#box( + fill: rgb("#f8fafc"), + stroke: rgb("#d0d7de"), + radius: 6pt, + inset: (x: 10pt, y: 8pt), + )[ + #grid( + columns: (auto, 1fr), + gutter: 8pt, + align: top, + )[ + #text(size: 8pt, weight: "bold", fill: rgb("#101820"), "[{step_number}]") + {} + ] + ] {}"##, + body, + typst_label_ref(&label), + ) +} + +fn render_step_rule_info_typst(step: &ProofStep) -> Option { + if step + .rule_name + .as_deref() + .map(is_administrative_proof_rule_name) + .unwrap_or(false) + { + return Some(format!( + r##"#text(size: 8pt, weight: "bold", fill: rgb("#101820"))[Initialization]"## + )); + } + + let mut lines = Vec::new(); + if let Some(rule_name) = step + .rule_name + .as_deref() + .filter(|rule_name| !rule_name.is_empty()) + { + lines.push(format!( + r##"#text(size: 8pt, weight: "bold", fill: rgb("#101820"))[{}]"##, + typst_raw_text(rule_name) + )); + } + if let Some(detail) = step.rule_detail.as_ref() { + lines.push(format!( + r##"#text(size: 8pt, fill: rgb("#52606d"))[{}]"##, + typst_raw_text(detail) + )); + } + let rule_formula = step.rule_formula.as_ref().map(|rule_formula| { + format!( + r##"#text(size: 8pt, fill: rgb("#52606d"))[{}]"##, + typst_math(rule_formula) + ) + }); + let substitution = step.substitution.as_ref().map(|subst| { + format!( + r##"#text(size: 8pt, fill: rgb("#52606d"))[{}]"##, + typst_math(subst) + ) + }); + match (rule_formula, substitution) { + (Some(rule_formula), Some(substitution)) => lines.push(format!( + r##"#grid( + columns: (1fr, auto), + gutter: 12pt, + align: top, + )[ + {} + {} + ]"##, + rule_formula, substitution + )), + (Some(rule_formula), None) => lines.push(rule_formula), + (None, Some(substitution)) => lines.push(substitution), + (None, None) => {} + } + if lines.is_empty() { + None + } else { + Some(format!( + r##"#stack(spacing: 2pt)[ + {} + ]"##, + lines.join("\n ") + )) + } +} + +fn render_proof_proposition( + sexp: &ProofSexp, + bindings: &BTreeMap, + templates: &ProofRulesTemplateIndex, + rule_template: Option<&ProofRuleTemplate>, +) -> Option { + let eq = extract_proof_proposition_eq(sexp, bindings)?; + let rewrites = BTreeMap::new(); + render_proof_proposition_eq( + eq, + bindings, + templates, + rule_template, + &rewrites, + None, + None, + ) +} + +fn render_proof_proposition_eq( + eq: &ProofSexp, + bindings: &BTreeMap, + templates: &ProofRulesTemplateIndex, + rule_template: Option<&ProofRuleTemplate>, + rewrites: &BTreeMap, + highlights: Option<&BTreeMap>, + highlight_links: Option<&BTreeMap>, +) -> Option { + let Some((lhs_sexp, rhs_sexp)) = displayed_equality_terms(eq, bindings) else { + return None; + }; + let lhs = render_proof_term( + lhs_sexp, + bindings, + templates, + rule_template, + rewrites, + highlights, + highlight_links, + ); + let rhs = render_proof_term( + rhs_sexp, + bindings, + templates, + rule_template, + rewrites, + highlights, + highlight_links, + ); + Some(format!("{} = {}", lhs.text, rhs.text)) +} + +fn render_proof_target_term( + eq: &ProofSexp, + bindings: &BTreeMap, + templates: &ProofRulesTemplateIndex, + rule_template: Option<&ProofRuleTemplate>, +) -> Option { + let (lhs_sexp, _) = displayed_equality_terms(eq, bindings)?; + let rewrites = BTreeMap::new(); + Some( + render_proof_term( + lhs_sexp, + bindings, + templates, + rule_template, + &rewrites, + None, + None, + ) + .text, + ) +} + +fn displayed_equality_terms<'a>( + eq: &'a ProofSexp, + bindings: &'a BTreeMap, +) -> Option<(&'a ProofSexp, &'a ProofSexp)> { + let eq = resolve_proof_reference(eq, bindings); + let ProofSexp::List(items) = eq else { + return None; + }; + if items.len() != 3 || items[0].as_atom() != Some("=") { + return None; + } + Some((&items[1], &items[2])) +} + +fn extract_proof_proposition_eq<'a>( + sexp: &'a ProofSexp, + bindings: &'a BTreeMap, +) -> Option<&'a ProofSexp> { + let sexp = resolve_proof_reference(sexp, bindings); + let ProofSexp::List(items) = sexp else { + return None; + }; + let eq = items.get(1)?; + let eq = resolve_proof_reference(eq, bindings); + let ProofSexp::List(items) = eq else { + return None; + }; + if items.len() != 3 || items[0].as_atom() != Some("=") { + return None; + } + Some(eq) +} + +fn find_preferred_rule_template<'a>( + sexp: &'a ProofSexp, + bindings: &'a BTreeMap, + templates: &'a ProofRulesTemplateIndex, +) -> Option<&'a ProofRuleTemplate> { + find_preferred_rule_template_inner(sexp, bindings, templates, &mut HashSet::new()) +} + +fn find_preferred_rule_template_inner<'a>( + sexp: &'a ProofSexp, + bindings: &'a BTreeMap, + templates: &'a ProofRulesTemplateIndex, + seen: &mut HashSet, +) -> Option<&'a ProofRuleTemplate> { + let sexp = resolve_proof_reference(sexp, bindings); + let key = sexp_key(sexp); + if !seen.insert(key) { + return None; + } + + match sexp { + ProofSexp::Atom(name) => bindings + .get(name) + .and_then(|bound| find_preferred_rule_template_inner(bound, bindings, templates, seen)), + ProofSexp::String(_) => None, + ProofSexp::List(items) => { + if items.first().and_then(ProofSexp::as_atom) == Some("Rule") { + if let Some(rule_name) = extract_rule_name(sexp) { + if let ProofRuleTemplateMatch::Unique(template) = templates.lookup(&rule_name) { + return Some(template); + } + } + } + for item in items.iter().skip(1) { + if let Some(template) = + find_preferred_rule_template_inner(item, bindings, templates, seen) + { + return Some(template); + } + } + None + } + } +} + +fn extract_rule_name(sexp: &ProofSexp) -> Option { + let ProofSexp::List(items) = sexp else { + return None; + }; + if items.first().and_then(ProofSexp::as_atom) != Some("Rule") { + return None; + } + items.get(2).and_then(|sexp| match sexp { + ProofSexp::List(list) if list.len() == 2 => list + .get(1) + .and_then(ProofSexp::as_string) + .or_else(|| list.get(1).and_then(ProofSexp::as_atom)) + .map(str::to_owned), + _ => None, + }) +} + +fn collect_proof_steps( + sexp: &ProofSexp, + bindings: &BTreeMap, + templates: &ProofRulesTemplateIndex, + steps: &mut Vec, + seen: &mut HashSet, + rewrites: &mut BTreeMap, + proposition_ctx: Option, + reverse_eq: bool, +) { + match sexp { + ProofSexp::Atom(name) => { + if let Some(bound) = bindings.get(name) { + let key = format!("binding:{reverse_eq}:{name}"); + if seen.insert(key) { + collect_proof_steps( + bound, + bindings, + templates, + steps, + seen, + rewrites, + proposition_ctx, + reverse_eq, + ); + } + } + } + ProofSexp::String(_) => {} + ProofSexp::List(items) => { + let Some(head) = items.first().and_then(ProofSexp::as_atom) else { + return; + }; + let key = format!("{}:{reverse_eq}", sexp_key(sexp)); + if !seen.insert(key) { + return; + } + + match head { + "let" => { + if let Some(bound) = items.get(2) { + collect_proof_steps( + bound, + bindings, + templates, + steps, + seen, + rewrites, + proposition_ctx, + reverse_eq, + ); + } + } + "Fiat" => { + if let Some(eq) = items + .get(1) + .filter(|eq| !is_reflexive_equality(eq, bindings)) + { + push_rendered_proof_step( + steps, + rewrites, + eq, + None, + None, + None, + None, + bindings, + templates, + None, + proposition_ctx, + reverse_eq, + ); + } + } + "Rule" => { + let eq = items.get(1); + let rule_name = extract_rule_name(sexp).unwrap_or_else(|| "unknown".to_owned()); + let local_rule = templates.lookup(&rule_name); + let (rule_template, rule_label, rule_detail) = match local_rule { + ProofRuleTemplateMatch::Unique(template) => ( + Some(template), + non_empty_or(&template.display_name, &rule_name), + None, + ), + ProofRuleTemplateMatch::Ambiguous(matches) => ( + None, + format!("{rule_name} (ambiguous)"), + Some(format!("{} rules.template matches", matches.len())), + ), + ProofRuleTemplateMatch::Missing => ( + None, + rule_name.clone(), + Some("no rules.template match".to_owned()), + ), + }; + if let Some(rule_template) = rule_template { + if let Some(premises) = items.get(3).and_then(extract_named_list) { + for premise in premises { + collect_proof_steps( + premise, + bindings, + templates, + steps, + seen, + rewrites, + proposition_ctx, + false, + ); + } + } + let substitution = items + .get(4) + .and_then(extract_named_list) + .map(|pairs| { + render_substitution_pairs( + pairs, + bindings, + templates, + Some(rule_template), + rewrites, + ) + }) + .filter(|text| !text.is_empty()); + push_rendered_proof_step( + steps, + rewrites, + eq.unwrap_or(sexp), + Some(rule_label), + rule_detail, + substitution, + rule_template + .formula_colored + .as_ref() + .or(rule_template.formula.as_ref()) + .cloned(), + bindings, + templates, + Some(rule_template), + proposition_ctx, + reverse_eq, + ); + } else { + if let Some(premises) = items.get(3).and_then(extract_named_list) { + for premise in premises { + collect_proof_steps( + premise, + bindings, + templates, + steps, + seen, + rewrites, + proposition_ctx, + false, + ); + } + } + let substitution = items + .get(4) + .and_then(extract_named_list) + .map(|pairs| { + render_substitution_pairs( + pairs, bindings, templates, None, rewrites, + ) + }) + .filter(|text| !text.is_empty()); + push_rendered_proof_step( + steps, + rewrites, + eq.unwrap_or(sexp), + Some(rule_label), + rule_detail, + substitution, + None, + bindings, + templates, + None, + proposition_ctx, + reverse_eq, + ); + } + } + "Trans" => { + let left = items.get(2); + let right = items.get(3); + if reverse_eq { + if let Some(right) = right { + collect_proof_steps( + right, + bindings, + templates, + steps, + seen, + rewrites, + proposition_ctx, + true, + ); + } + if let Some(left) = left { + collect_proof_steps( + left, + bindings, + templates, + steps, + seen, + rewrites, + proposition_ctx, + true, + ); + } + } else { + if let Some(left) = left { + collect_proof_steps( + left, + bindings, + templates, + steps, + seen, + rewrites, + proposition_ctx, + false, + ); + } + if let Some(right) = right { + collect_proof_steps( + right, + bindings, + templates, + steps, + seen, + rewrites, + proposition_ctx, + false, + ); + } + } + } + "Sym" => { + if let Some(inner) = items.get(2) { + collect_proof_steps( + inner, + bindings, + templates, + steps, + seen, + rewrites, + proposition_ctx, + !reverse_eq, + ); + } + } + "Merge" => { + if let Some(old) = items.get(2) { + collect_proof_steps( + old, + bindings, + templates, + steps, + seen, + rewrites, + proposition_ctx, + reverse_eq, + ); + } + if let Some(new) = items.get(3) { + collect_proof_steps( + new, + bindings, + templates, + steps, + seen, + rewrites, + proposition_ctx, + reverse_eq, + ); + } + if let Some(eq) = items.get(1) { + push_rendered_proof_step( + steps, + rewrites, + eq, + Some("Merge".to_owned()), + None, + None, + None, + bindings, + templates, + None, + proposition_ctx, + reverse_eq, + ); + } + } + "Congr" => { + if let Some(base) = items.get(2) { + collect_proof_steps( + base, + bindings, + templates, + steps, + seen, + rewrites, + proposition_ctx, + reverse_eq, + ); + } + if let Some(child) = items.get(4) { + collect_proof_steps( + child, + bindings, + templates, + steps, + seen, + rewrites, + proposition_ctx, + reverse_eq, + ); + } + if let Some(eq) = items.get(1) { + push_rendered_proof_step( + steps, + rewrites, + eq, + Some("Congr".to_owned()), + None, + None, + None, + bindings, + templates, + None, + proposition_ctx, + reverse_eq, + ); + } + } + _ => { + if let Some(bound) = bindings.get(head) { + collect_proof_steps( + bound, + bindings, + templates, + steps, + seen, + rewrites, + proposition_ctx, + reverse_eq, + ); + } + } + } + } + } +} + +fn push_rendered_proof_step( + steps: &mut Vec, + rewrites: &mut BTreeMap, + eq: &ProofSexp, + rule_name: Option, + rule_detail: Option, + substitution: Option, + rule_formula: Option, + bindings: &BTreeMap, + templates: &ProofRulesTemplateIndex, + rule_template: Option<&ProofRuleTemplate>, + proposition_ctx: Option, + reverse_eq: bool, +) { + let mut step = render_proof_step( + eq, + rule_name, + rule_detail, + substitution, + rule_formula, + bindings, + templates, + rule_template, + rewrites, + reverse_eq, + ); + record_display_rewrite(eq, bindings, templates, rule_template, rewrites, reverse_eq); + if proposition_ctx.is_some() { + step.proposition_after_rewrites = Some(rewrites.clone()); + } + steps.push(step); +} + +fn render_proof_step( + eq: &ProofSexp, + rule_name: Option, + rule_detail: Option, + substitution: Option, + rule_formula: Option, + bindings: &BTreeMap, + templates: &ProofRulesTemplateIndex, + rule_template: Option<&ProofRuleTemplate>, + rewrites: &BTreeMap, + reverse_eq: bool, +) -> ProofStep { + let formula = render_proof_equality( + eq, + bindings, + templates, + rule_template, + rewrites, + reverse_eq, + None, + None, + ); + let matched_key = displayed_equality_terms(eq, bindings).map(|(lhs, rhs)| { + let target = if reverse_eq { rhs } else { lhs }; + sexp_key(resolve_proof_reference(target, bindings)) + }); + ProofStep { + formula, + proposition_after_rewrites: None, + matched_key, + rule_name, + rule_detail, + substitution, + rule_formula, + } +} + +fn render_proof_equality( + sexp: &ProofSexp, + bindings: &BTreeMap, + templates: &ProofRulesTemplateIndex, + rule_template: Option<&ProofRuleTemplate>, + rewrites: &BTreeMap, + reverse_eq: bool, + highlights: Option<&BTreeMap>, + highlight_links: Option<&BTreeMap>, +) -> String { + let sexp = resolve_proof_reference(sexp, bindings); + match sexp { + ProofSexp::List(items) if items.len() == 3 && items[0].as_atom() == Some("=") => { + let (lhs_sexp, rhs_sexp) = if reverse_eq { + (&items[2], &items[1]) + } else { + (&items[1], &items[2]) + }; + let lhs = render_proof_term( + lhs_sexp, + bindings, + templates, + rule_template, + rewrites, + highlights, + highlight_links, + ); + let rhs = render_proof_term( + rhs_sexp, + bindings, + templates, + rule_template, + rewrites, + highlights, + highlight_links, + ); + format!("{} arrow.r.double {}", lhs.text, rhs.text) + } + _ => { + render_proof_term( + sexp, + bindings, + templates, + rule_template, + rewrites, + highlights, + highlight_links, + ) + .text + } + } +} + +fn is_reflexive_equality(sexp: &ProofSexp, bindings: &BTreeMap) -> bool { + let sexp = resolve_proof_reference(sexp, bindings); + matches!( + sexp, + ProofSexp::List(items) + if items.len() == 3 + && items[0].as_atom() == Some("=") + && sexp_key(resolve_proof_reference(&items[1], bindings)) + == sexp_key(resolve_proof_reference(&items[2], bindings)) + ) +} + +#[derive(Clone, Debug)] +struct RenderedProofTerm { + text: String, + precedence: u16, +} + +impl RenderedProofTerm { + fn atom(text: impl Into) -> Self { + Self { + text: text.into(), + precedence: u16::MAX, + } + } +} + +fn maybe_highlight_rendered_term( + term: RenderedProofTerm, + highlight: Option, + link_target: Option<&str>, +) -> RenderedProofTerm { + let Some(highlight) = highlight else { + return term; + }; + RenderedProofTerm { + text: typst_highlight_math_fragment(&term.text, highlight, link_target), + precedence: term.precedence, + } +} + +fn render_proof_term( + sexp: &ProofSexp, + bindings: &BTreeMap, + templates: &ProofRulesTemplateIndex, + rule_template: Option<&ProofRuleTemplate>, + rewrites: &BTreeMap, + highlights: Option<&BTreeMap>, + highlight_links: Option<&BTreeMap>, +) -> RenderedProofTerm { + let sexp = resolve_proof_reference(sexp, bindings); + let sexp_key = sexp_key(sexp); + let highlight = highlights.and_then(|highlights| highlights.get(&sexp_key).copied()); + let link_target = match highlight { + Some(ProofHighlightKind::Matched) => { + highlight_links.and_then(|links| links.get(&sexp_key).map(String::as_str)) + } + _ => None, + }; + if let Some(rewritten) = rewrites.get(&sexp_key) { + return maybe_highlight_rendered_term(rewritten.clone(), highlight, link_target); + } + let rendered = match sexp { + ProofSexp::Atom(atom) => render_atom_term(atom), + ProofSexp::String(text) => RenderedProofTerm::atom(typst_string_literal(text)), + ProofSexp::List(items) => { + let Some(head) = items.first().and_then(ProofSexp::as_atom) else { + return RenderedProofTerm::atom("()"); + }; + let variant = rule_template + .and_then(|template| template.lookup_variant(head)) + .or_else(|| templates.lookup_variant(head)); + if let Some(variant) = variant { + if variant.fields.len() == items.len() - 1 { + let rendered_fields = variant + .fields + .iter() + .zip(items.iter().skip(1)) + .map(|(field_name, value)| { + ( + field_name.as_str(), + render_proof_term( + value, + bindings, + templates, + rule_template, + rewrites, + highlights, + highlight_links, + ), + ) + }) + .collect::>(); + let field_refs = rendered_fields + .iter() + .map(|(field_name, value)| { + ( + *field_name, + RenderedTemplateField::new(value.text.as_str(), value.precedence), + ) + }) + .collect::>(); + return maybe_highlight_rendered_term( + RenderedProofTerm { + text: render_template_with_precedence( + &variant.template, + variant.precedence, + &field_refs, + ), + precedence: variant.precedence, + }, + highlight, + link_target, + ); + } + } + + let rendered_args = items + .iter() + .skip(1) + .map(|item| { + render_proof_term( + item, + bindings, + templates, + rule_template, + rewrites, + highlights, + highlight_links, + ) + }) + .collect::>(); + let args = rendered_args + .iter() + .map(|arg| arg.text.as_str()) + .collect::>() + .join(", "); + RenderedProofTerm { + text: format!("upright({})({args})", typst_string_literal(head)), + precedence: u16::MAX, + } + } + }; + maybe_highlight_rendered_term(rendered, highlight, link_target) +} + +fn render_atom_term(atom: &str) -> RenderedProofTerm { + if atom.parse::().is_ok() || atom.parse::().is_ok() { + RenderedProofTerm::atom(atom.to_owned()) + } else if is_single_math_identifier(atom) { + RenderedProofTerm::atom(atom.to_owned()) + } else { + RenderedProofTerm::atom(format!("upright({})", typst_string_literal(atom))) + } +} + +fn is_single_math_identifier(atom: &str) -> bool { + let mut chars = atom.chars(); + matches!(chars.next(), Some(first) if first.is_ascii_alphabetic()) && chars.next().is_none() +} + +fn render_substitution_pairs( + pairs: &[ProofSexp], + bindings: &BTreeMap, + templates: &ProofRulesTemplateIndex, + rule_template: Option<&ProofRuleTemplate>, + rewrites: &BTreeMap, +) -> String { + if let Some(text) = + render_semantic_bindings(pairs, bindings, templates, rule_template, rewrites) + { + return text; + } + let rendered = pairs + .iter() + .filter_map(|pair| { + let ProofSexp::List(items) = pair else { + return None; + }; + if items.len() != 2 { + return None; + } + let name = items[0].as_atom().or_else(|| items[0].as_string())?; + let value = render_proof_term( + &items[1], + bindings, + templates, + rule_template, + rewrites, + None, + None, + ); + Some(format!("{} = {}", render_atom_term(name).text, value.text)) + }) + .collect::>(); + rendered.join(", ") +} + +#[derive(Clone)] +struct RenderedBindingCandidate { + sort_key: (u8, usize, usize), + value: RenderedProofTerm, +} + +fn render_semantic_bindings( + pairs: &[ProofSexp], + bindings: &BTreeMap, + templates: &ProofRulesTemplateIndex, + rule_template: Option<&ProofRuleTemplate>, + rewrites: &BTreeMap, +) -> Option { + let rule_template = rule_template?; + let math_view = rule_template.math_view.as_ref()?; + // The proof encoder leaks internal `expr*` placeholders here. + // For display, prefer the rule's semantic premise ids from the DSL/template. + let labels = math_view + .premises + .iter() + .map(|premise| premise.target_id.trim()) + .filter(|label| !label.is_empty()) + .map(str::to_owned) + .collect::>(); + if labels.is_empty() { + return None; + } + + let mut candidates = + collect_binding_candidates(pairs, bindings, templates, Some(rule_template), rewrites); + if candidates.is_empty() || candidates.len() < labels.len() { + return None; + } + candidates.sort_by_key(|candidate| candidate.sort_key); + + let label_count = labels.len(); + Some( + labels + .into_iter() + .zip(candidates.into_iter().take(label_count)) + .map(|(label, candidate)| format!("{label} = {}", candidate.value.text)) + .collect::>() + .join(", "), + ) +} + +fn collect_binding_candidates( + pairs: &[ProofSexp], + bindings: &BTreeMap, + templates: &ProofRulesTemplateIndex, + rule_template: Option<&ProofRuleTemplate>, + rewrites: &BTreeMap, +) -> Vec { + pairs + .iter() + .enumerate() + .filter_map(|(idx, pair)| { + let ProofSexp::List(items) = pair else { + return None; + }; + if items.len() != 2 { + return None; + } + let name = items[0].as_atom().or_else(|| items[0].as_string())?; + if name.ends_with("num") { + return None; + } + let sort_key = binding_sort_key(name, idx); + let value = render_proof_term( + &items[1], + bindings, + templates, + rule_template, + rewrites, + None, + None, + ); + Some(RenderedBindingCandidate { sort_key, value }) + }) + .collect() +} + +fn record_display_rewrite( + eq: &ProofSexp, + bindings: &BTreeMap, + templates: &ProofRulesTemplateIndex, + rule_template: Option<&ProofRuleTemplate>, + rewrites: &mut BTreeMap, + reverse_eq: bool, +) { + let sexp = resolve_proof_reference(eq, bindings); + let ProofSexp::List(items) = sexp else { + return; + }; + if items.len() != 3 || items[0].as_atom() != Some("=") { + return; + } + let (lhs_sexp, rhs_sexp) = if reverse_eq { + (&items[2], &items[1]) + } else { + (&items[1], &items[2]) + }; + let lhs_key = sexp_key(resolve_proof_reference(lhs_sexp, bindings)); + let lhs = render_proof_term( + lhs_sexp, + bindings, + templates, + rule_template, + rewrites, + None, + None, + ); + let rhs = render_proof_term( + rhs_sexp, + bindings, + templates, + rule_template, + rewrites, + None, + None, + ); + if lhs.text == rhs.text { + return; + } + rewrites.insert(lhs_key, rhs); +} + +fn binding_sort_key(name: &str, index: usize) -> (u8, usize, usize) { + if let Some(num) = trailing_digits(name) { + return (0, num, index); + } + (1, usize::MAX, index) +} + +fn trailing_digits(text: &str) -> Option { + let mut start = text.len(); + for (idx, ch) in text.char_indices().rev() { + if ch.is_ascii_digit() { + start = idx; + } else { + break; + } + } + if start == text.len() { + return None; + } + text[start..].parse().ok() +} + +fn collect_proof_bindings(sexps: &[ProofSexp]) -> BTreeMap { + let mut bindings = BTreeMap::new(); + for sexp in sexps { + let Some((head, items)) = sexp.as_list_head() else { + continue; + }; + if head == "let" && items.len() == 2 { + if let Some(name) = items[0].as_atom() { + bindings.insert(name.to_owned(), items[1].clone()); + } + } + } + bindings +} + +fn is_let_binding(sexp: &ProofSexp) -> bool { + matches!(sexp.as_list_head(), Some((head, items)) if head == "let" && items.len() == 2) +} + +fn resolve_proof_reference<'a>( + sexp: &'a ProofSexp, + bindings: &'a BTreeMap, +) -> &'a ProofSexp { + let mut current = sexp; + let mut seen = HashSet::new(); + while let ProofSexp::Atom(name) = current { + if !seen.insert(name) { + break; + } + let Some(next) = bindings.get(name) else { + break; + }; + current = next; + } + current +} + +fn extract_named_list(sexp: &ProofSexp) -> Option<&[ProofSexp]> { + let ProofSexp::List(items) = sexp else { + return None; + }; + if items.len() < 1 { + return None; + } + Some(&items[1..]) +} + +fn parse_proof_sexps(text: &str) -> Option> { + let mut parser = ProofSexpParser::new(text); + let mut out = Vec::new(); + parser.skip_ws(); + while !parser.eof() { + out.push(parser.parse_sexp().ok()?); + parser.skip_ws(); + } + Some(out) +} + +struct ProofSexpParser<'a> { + chars: Vec, + idx: usize, + _text: &'a str, +} + +impl<'a> ProofSexpParser<'a> { + fn new(text: &'a str) -> Self { + Self { + chars: text.chars().collect(), + idx: 0, + _text: text, + } + } + + fn eof(&self) -> bool { + self.idx >= self.chars.len() + } + + fn skip_ws(&mut self) { + while let Some(ch) = self.chars.get(self.idx) { + if ch.is_whitespace() { + self.idx += 1; + } else { + break; + } + } + } + + fn parse_sexp(&mut self) -> Result { + self.skip_ws(); + let Some(ch) = self.chars.get(self.idx).copied() else { + return Err(()); + }; + match ch { + '(' => self.parse_list(), + '"' => self.parse_string(), + _ => Ok(self.parse_atom()), + } + } + + fn parse_list(&mut self) -> Result { + self.idx += 1; + let mut items = Vec::new(); + loop { + self.skip_ws(); + let Some(ch) = self.chars.get(self.idx).copied() else { + return Err(()); + }; + if ch == ')' { + self.idx += 1; + return Ok(ProofSexp::List(items)); + } + items.push(self.parse_sexp()?); + } + } + + fn parse_string(&mut self) -> Result { + self.idx += 1; + let mut out = String::new(); + let mut escaped = false; + while let Some(ch) = self.chars.get(self.idx).copied() { + self.idx += 1; + if escaped { + out.push(match ch { + 'n' => '\n', + 't' => '\t', + 'r' => '\r', + '"' => '"', + '\\' => '\\', + other => other, + }); + escaped = false; + } else if ch == '\\' { + escaped = true; + } else if ch == '"' { + return Ok(ProofSexp::String(out)); + } else { + out.push(ch); + } + } + Err(()) + } + + fn parse_atom(&mut self) -> ProofSexp { + let start = self.idx; + while let Some(ch) = self.chars.get(self.idx).copied() { + if ch.is_whitespace() || ch == '(' || ch == ')' { + break; + } + self.idx += 1; + } + ProofSexp::Atom(self.chars[start..self.idx].iter().collect()) + } +} + +impl ProofSexp { + fn as_atom(&self) -> Option<&str> { + match self { + ProofSexp::Atom(atom) => Some(atom.as_str()), + _ => None, + } + } + + fn as_string(&self) -> Option<&str> { + match self { + ProofSexp::String(text) => Some(text.as_str()), + _ => None, + } + } + + fn as_list_head(&self) -> Option<(&str, &[ProofSexp])> { + match self { + ProofSexp::List(items) if !items.is_empty() => Some((items[0].as_atom()?, &items[1..])), + _ => None, + } + } +} + +fn sexp_key(sexp: &ProofSexp) -> String { + match sexp { + ProofSexp::Atom(atom) => format!("atom:{atom}"), + ProofSexp::String(text) => format!("string:{text:?}"), + ProofSexp::List(items) => { + let mut out = String::from("list:"); + for item in items { + out.push_str(&sexp_key(item)); + out.push(';'); + } + out + } + } +} + +pub fn render_proof_svg_from_rules_template( + proof_text: &str, + rules_template_path: impl AsRef, +) -> Result { + let index = ProofRulesTemplateIndex::from_path(rules_template_path)?; + render_proof_text_svg(proof_text, &index) +} + +pub fn render_proof_svg_from_rules_template_with_options( + proof_text: &str, + rules_template_path: impl AsRef, + concise: bool, +) -> Result { + let index = ProofRulesTemplateIndex::from_path(rules_template_path)?; + render_proof_text_svg_with_options(proof_text, &index, concise) +} + +/// Render egglog proof text into a standalone Typst document. +/// +/// The proof formatter keeps egglog's proof-line structure intact, but replaces +/// `(name "...")` fragments with Typst rule badges resolved from `rules.template`. +pub fn render_proof_text_typst(proof_text: &str, templates: &ProofRulesTemplateIndex) -> String { + ProofSvgFormatter::default().render_document_typst(proof_text, templates) +} + +pub fn render_proof_text_typst_with_options( + proof_text: &str, + templates: &ProofRulesTemplateIndex, + concise: bool, +) -> String { + ProofSvgFormatter::default() + .concise(concise) + .render_document_typst(proof_text, templates) +} + +pub fn render_value_proof_text_typst( + proof_text: &str, + templates: &ProofRulesTemplateIndex, +) -> String { + ProofSvgFormatter::default().render_value_document_typst(proof_text, templates) +} + +pub fn render_value_proof_text_typst_with_options( + proof_text: &str, + templates: &ProofRulesTemplateIndex, + concise: bool, +) -> String { + ProofSvgFormatter::default() + .concise(concise) + .render_value_document_typst(proof_text, templates) +} + +/// Render egglog proof text to SVG by compiling the generated Typst document. +/// +/// This requires the `typst` CLI to be available on `PATH`. +pub fn render_proof_text_svg( + proof_text: &str, + templates: &ProofRulesTemplateIndex, +) -> Result { + ProofSvgFormatter::default().render(proof_text, templates) +} + +pub fn render_proof_text_svg_with_options( + proof_text: &str, + templates: &ProofRulesTemplateIndex, + concise: bool, +) -> Result { + ProofSvgFormatter::default() + .concise(concise) + .render(proof_text, templates) +} + +pub fn render_value_proof_text_svg( + proof_text: &str, + templates: &ProofRulesTemplateIndex, +) -> Result { + ProofSvgFormatter::default().render_value(proof_text, templates) +} + +pub fn render_value_proof_text_svg_with_options( + proof_text: &str, + templates: &ProofRulesTemplateIndex, + concise: bool, +) -> Result { + ProofSvgFormatter::default() + .concise(concise) + .render_value(proof_text, templates) +} + +#[derive(Clone, Debug)] +pub struct ProofSvgFormatter { + row_gap_pt: f32, + concise: bool, +} + +impl Default for ProofSvgFormatter { + fn default() -> Self { + Self { + row_gap_pt: 7.0, + concise: false, + } + } +} + +impl ProofSvgFormatter { + pub fn concise(mut self, concise: bool) -> Self { + self.concise = concise; + self + } + + pub fn render( + &self, + proof_text: &str, + templates: &ProofRulesTemplateIndex, + ) -> Result { + let svg = compile_typst_document_to_svg_string( + &self.render_document_typst(proof_text, templates), + )?; + Ok(if self.concise { + inject_concise_proof_svg_links(&svg) + } else { + svg + }) + } + + fn render_document_typst( + &self, + proof_text: &str, + templates: &ProofRulesTemplateIndex, + ) -> String { + render_structured_proof_text_typst(proof_text, templates, self.concise) + .unwrap_or_else(|| self.render_typst(proof_text, templates)) + } + + fn render_value_document_typst( + &self, + proof_text: &str, + templates: &ProofRulesTemplateIndex, + ) -> String { + render_structured_value_proof_text_typst(proof_text, templates, self.concise) + .unwrap_or_else(|| self.render_typst(proof_text, templates)) + } + + pub fn render_typst(&self, proof_text: &str, templates: &ProofRulesTemplateIndex) -> String { + let parsed_lines = if proof_text.is_empty() { + vec![parse_proof_line("")] + } else { + proof_text.lines().map(parse_proof_line).collect::>() + }; + let mut out = String::new(); + out.push_str(PROOF_TYPST_PREAMBLE); + let _ = writeln!( + out, + r##"#box( + fill: rgb("#ffffff"), + stroke: rgb("#d0d7de"), + radius: 8pt, + inset: (x: 14pt, y: 14pt), +)[ + #stack(spacing: {:.1}pt,"##, + self.row_gap_pt + ); + for line in &parsed_lines { + let _ = writeln!(out, " [{}],", self.render_line_typst(line, templates)); + } + out.push_str(" )\n]\n"); + out + } + + fn render_value( + &self, + proof_text: &str, + templates: &ProofRulesTemplateIndex, + ) -> Result { + let svg = compile_typst_document_to_svg_string( + &self.render_value_document_typst(proof_text, templates), + )?; + Ok(if self.concise { + inject_concise_proof_svg_links(&svg) + } else { + svg + }) + } + + fn render_line_typst( + &self, + line: &ParsedProofLine, + templates: &ProofRulesTemplateIndex, + ) -> String { + let mut out = String::new(); + let mut emitted_segment = false; + for segment in &line.segments { + match segment { + ProofLineSegment::Text(text) => { + if !text.is_empty() { + let _ = write!(out, "#raw({})", typst_string_literal(text)); + emitted_segment = true; + } + } + ProofLineSegment::RuleName(name) => { + if emitted_segment { + out.push_str(" #h(8pt) "); + } + let badge = badge_for_rule(name, templates); + let _ = write!( + out, + "#proof-badge({}, {}, rgb(\"{}\"), rgb(\"{}\"))", + typst_string_literal(&badge.label), + typst_string_literal(&badge.detail), + badge.fill, + badge.stroke + ); + emitted_segment = true; + } + } + } + if !emitted_segment { + out.push_str("#raw(\"\")"); + } + out + } +} + +const PROOF_TYPST_PREAMBLE: &str = r##"#set page(width: auto, height: auto, margin: 8pt) +#set text(size: 13pt, fill: rgb("#17212b")) +#let proof-badge(label, detail, fill, stroke) = box( + fill: fill, + stroke: stroke, + radius: 5pt, + inset: (x: 8pt, y: 5pt), +)[ + #text(size: 10pt, weight: "bold", fill: rgb("#101820"))[#label] + #linebreak() + #text(size: 8pt, fill: rgb("#52606d"))[#detail] +] + +"##; + +#[derive(Clone, Debug)] +struct ParsedProofLine { + segments: Vec, +} + +#[derive(Clone, Debug)] +enum ProofLineSegment { + Text(String), + RuleName(String), +} + +#[derive(Clone, Debug)] +struct RuleBadge { + label: String, + detail: String, + fill: &'static str, + stroke: &'static str, +} + +fn parse_proof_line(line: &str) -> ParsedProofLine { + let mut segments = Vec::new(); + let mut cursor = 0; + while let Some(relative_start) = line[cursor..].find("(name \"") { + let start = cursor + relative_start; + let name_start = start + "(name \"".len(); + let Some(name_end) = find_unescaped_quote(line, name_start) else { + break; + }; + if start > cursor { + segments.push(ProofLineSegment::Text(line[cursor..start].to_owned())); + } + segments.push(ProofLineSegment::RuleName( + line[name_start..name_end].to_owned(), + )); + cursor = if line.as_bytes().get(name_end + 1) == Some(&b')') { + name_end + 2 + } else { + name_end + 1 + }; + } + if cursor < line.len() || segments.is_empty() { + segments.push(ProofLineSegment::Text(line[cursor..].to_owned())); + } + ParsedProofLine { segments } +} + +fn find_unescaped_quote(text: &str, start: usize) -> Option { + let bytes = text.as_bytes(); + let mut idx = start; + let mut escaped = false; + while idx < bytes.len() { + let byte = bytes[idx]; + if escaped { + escaped = false; + } else if byte == b'\\' { + escaped = true; + } else if byte == b'"' { + return Some(idx); + } + idx += 1; + } + None +} + +fn badge_for_rule(rule_name: &str, templates: &ProofRulesTemplateIndex) -> RuleBadge { + match templates.lookup(rule_name) { + ProofRuleTemplateMatch::Unique(template) => { + let label = non_empty_or(&template.display_name, rule_name); + let detail = template + .formula + .as_deref() + .filter(|formula| !formula.trim().is_empty()) + .map(|formula| truncate_text(formula, 72)) + .unwrap_or_else(|| { + format!("{}:{}:{}", template.file, template.line, template.column) + }); + make_badge( + label, + detail, + if template.ok { BADGE_OK } else { BADGE_FAILED }, + ) + } + ProofRuleTemplateMatch::Ambiguous(matches) => { + // Proof text only carries the printed rule name (for example `@fib`). + // If several generated rules share that name, we cannot safely pick one + // without extra source identity from upstream proof encoding. + make_badge( + format!("{rule_name} (ambiguous)"), + format!("{} rules.template matches", matches.len()), + BADGE_AMBIGUOUS, + ) + } + ProofRuleTemplateMatch::Missing => make_badge( + rule_name.to_owned(), + "no rules.template match".to_owned(), + BADGE_MISSING, + ), + } +} + +#[derive(Clone, Copy, Debug)] +struct BadgeTone { + fill: &'static str, + stroke: &'static str, +} + +const BADGE_OK: BadgeTone = BadgeTone { + fill: "#f7fbff", + stroke: "#7aa7d9", +}; +const BADGE_FAILED: BadgeTone = BadgeTone { + fill: "#fff5f5", + stroke: "#d97878", +}; +const BADGE_AMBIGUOUS: BadgeTone = BadgeTone { + fill: "#fff8e6", + stroke: "#d39c28", +}; +const BADGE_MISSING: BadgeTone = BadgeTone { + fill: "#f3f4f6", + stroke: "#9ca3af", +}; + +fn make_badge(label: String, detail: String, tone: BadgeTone) -> RuleBadge { + let label = truncate_text(&label, 48); + let detail = truncate_text(&detail, 72); + RuleBadge { + label, + detail, + fill: tone.fill, + stroke: tone.stroke, + } +} + +fn rule_lookup_keys(template: &ProofRuleTemplate) -> Vec { + let mut keys = Vec::new(); + if let Some(rule_name) = template.rule_name.as_deref() { + push_rule_name_keys(&mut keys, rule_name); + } + if !template.display_name.is_empty() { + push_rule_name_keys(&mut keys, &template.display_name); + } + if !template.id.is_empty() { + push_unique(&mut keys, template.id.clone()); + } + keys +} + +fn proof_rule_lookup_keys(proof_rule_name: &str) -> Vec { + let mut keys = Vec::new(); + push_rule_name_keys(&mut keys, proof_rule_name); + keys +} + +fn push_rule_name_keys(keys: &mut Vec, name: &str) { + if name.is_empty() { + return; + } + push_unique(keys, name.to_owned()); + if let Some(stripped) = name.strip_prefix('@') { + push_unique(keys, stripped.to_owned()); + } else { + push_unique(keys, format!("@{name}")); + } +} + +fn push_unique(keys: &mut Vec, key: String) { + if !key.is_empty() && !keys.iter().any(|existing| existing == &key) { + keys.push(key); + } +} + +fn non_empty_or(value: &str, fallback: &str) -> String { + if value.is_empty() { + fallback.to_owned() + } else { + value.to_owned() + } +} + +fn truncate_text(text: &str, max_chars: usize) -> String { + if text.chars().count() <= max_chars { + return text.to_owned(); + } + let keep = max_chars.saturating_sub(1); + let mut out = text.chars().take(keep).collect::(); + out.push_str("..."); + out +} + +fn typst_string_literal(text: &str) -> String { + let mut out = String::with_capacity(text.len()); + out.push('"'); + for ch in text.chars() { + match ch { + '\\' => out.push_str("\\\\"), + '"' => out.push_str("\\\""), + '\n' => out.push_str("\\n"), + '\r' => out.push_str("\\r"), + '\t' => out.push_str("\\t"), + _ => out.push(ch), + } + } + out.push('"'); + out +} + +fn typst_raw_text(text: &str) -> String { + let mut out = String::from("#raw("); + out.push_str(&typst_string_literal(text)); + out.push(')'); + out +} + +fn typst_math(text: &str) -> String { + format!("${text}$") +} + +const MATCH_HIGHLIGHT_FILL: &str = "#fff4a3"; +const RESULT_HIGHLIGHT_FILL: &str = "#d7f7dd"; +const HIGHLIGHT_RADIUS_PT: &str = "2pt"; +const HIGHLIGHT_INSET_X_PT: &str = "2pt"; +const HIGHLIGHT_INSET_Y_PT: &str = "0.5pt"; + +fn proof_row_highlights( + previous_result_key: Option<&str>, + next_match_key: Option<&str>, +) -> BTreeMap { + let mut highlights = BTreeMap::new(); + if let Some(key) = previous_result_key { + highlights.insert(key.to_owned(), ProofHighlightKind::Result); + } + if let Some(key) = next_match_key { + highlights.insert(key.to_owned(), ProofHighlightKind::Matched); + } + highlights +} + +fn proof_row_link_targets( + next_match_key: Option<&str>, + next_step_label: Option<&str>, +) -> BTreeMap { + let mut targets = BTreeMap::new(); + if let (Some(key), Some(label)) = (next_match_key, next_step_label) { + targets.insert(key.to_owned(), label.to_owned()); + } + targets +} + +fn proof_step_label(step_number: usize) -> String { + format!("proof-step-{step_number}") +} + +fn proof_step_link_label(step_label: &str) -> String { + format!("proof-link-{step_label}") +} + +fn typst_label_ref(label: &str) -> String { + format!("<{label}>") +} + +fn typst_highlight_math_fragment( + text: &str, + highlight: ProofHighlightKind, + link_target: Option<&str>, +) -> String { + let fill = match highlight { + ProofHighlightKind::Matched => MATCH_HIGHLIGHT_FILL, + ProofHighlightKind::Result => RESULT_HIGHLIGHT_FILL, + }; + let box_markup = format!( + r##"#box( + fill: rgb("{}"), + radius: {}, + inset: (x: {}, y: {}), +)[${text}$]"##, + fill, HIGHLIGHT_RADIUS_PT, HIGHLIGHT_INSET_X_PT, HIGHLIGHT_INSET_Y_PT + ); + match (highlight, link_target) { + (ProofHighlightKind::Matched, Some(target)) => { + let link_label = proof_step_link_label(target); + format!( + "#link({})[{} {}]", + typst_label_ref(target), + box_markup, + typst_label_ref(&link_label) + ) + } + _ => box_markup, + } +} + +const PROOF_SVG_STEP_LABEL_PREFIX: &str = "proof-step-"; +const PROOF_SVG_LINK_LABEL_PREFIX: &str = "proof-link-"; + +fn inject_concise_proof_svg_links(svg: &str) -> String { + let with_ids = add_proof_step_svg_ids(svg); + wrap_proof_link_svg_groups(&with_ids) +} + +fn add_proof_step_svg_ids(svg: &str) -> String { + rewrite_svg_group_start_tags(svg, |tag| { + let Some(label) = svg_attr_value(tag, "data-typst-label") else { + return None; + }; + if !label.starts_with(PROOF_SVG_STEP_LABEL_PREFIX) || svg_attr_value(tag, "id").is_some() { + return None; + } + insert_svg_attr(tag, "id", label) + }) +} + +fn rewrite_svg_group_start_tags( + svg: &str, + mut rewrite: impl FnMut(&str) -> Option, +) -> String { + let mut out = String::with_capacity(svg.len()); + let mut cursor = 0; + while let Some(relative_start) = svg[cursor..].find("') else { + break; + }; + let tag_end = tag_start + relative_end + 1; + out.push_str(&svg[cursor..tag_start]); + let tag = &svg[tag_start..tag_end]; + if let Some(rewritten) = rewrite(tag) { + out.push_str(&rewritten); + } else { + out.push_str(tag); + } + cursor = tag_end; + } + out.push_str(&svg[cursor..]); + out +} + +fn wrap_proof_link_svg_groups(svg: &str) -> String { + let mut out = String::with_capacity(svg.len()); + let mut cursor = 0; + while let Some(relative_start) = svg[cursor..].find("') + .map(|idx| group_start + idx + 1) + else { + break; + }; + let tag = &svg[group_start..tag_end]; + let Some(label) = svg_attr_value(tag, "data-typst-label") else { + out.push_str(&svg[cursor..tag_end]); + cursor = tag_end; + continue; + }; + let Some(target) = label.strip_prefix(PROOF_SVG_LINK_LABEL_PREFIX) else { + out.push_str(&svg[cursor..tag_end]); + cursor = tag_end; + continue; + }; + let Some(group_end) = find_matching_svg_group_end(svg, group_start) else { + out.push_str(&svg[cursor..tag_end]); + cursor = tag_end; + continue; + }; + out.push_str(&svg[cursor..group_start]); + let escaped_target = escape_svg_attr_value(target); + let _ = write!( + out, + r##""##, + escaped_target, escaped_target + ); + out.push_str(&svg[group_start..group_end]); + out.push_str(""); + cursor = group_end; + } + out.push_str(&svg[cursor..]); + out +} + +fn find_matching_svg_group_end(svg: &str, group_start: usize) -> Option { + let mut cursor = group_start; + let mut depth = 0usize; + loop { + let start = find_next_svg_group_start(svg, cursor); + let close = svg[cursor..].find("").map(|idx| cursor + idx); + match (start, close) { + (Some(start), Some(close)) if start < close => { + depth = depth.saturating_add(1); + cursor = svg[start..].find('>').map(|idx| start + idx + 1)?; + } + (Some(start), None) => { + depth = depth.saturating_add(1); + cursor = svg[start..].find('>').map(|idx| start + idx + 1)?; + } + (_, Some(close)) => { + depth = depth.checked_sub(1)?; + cursor = close + "".len(); + if depth == 0 { + return Some(cursor); + } + } + (None, None) => return None, + } + } +} + +fn find_next_svg_group_start(svg: &str, cursor: usize) -> Option { + let mut search_from = cursor; + while let Some(relative_start) = svg[search_from..].find(" bool { + svg[idx..].starts_with("' || ch == '/' || ch.is_ascii_whitespace()) +} + +fn svg_attr_value<'a>(tag: &'a str, attr_name: &str) -> Option<&'a str> { + let needle = format!(r#"{attr_name}=""#); + let value_start = tag.find(&needle)? + needle.len(); + let value_end = tag[value_start..].find('"')? + value_start; + Some(&tag[value_start..value_end]) +} + +fn insert_svg_attr(tag: &str, attr_name: &str, attr_value: &str) -> Option { + let insert_at = tag.rfind('>')?; + let mut out = String::with_capacity(tag.len() + attr_name.len() + attr_value.len() + 5); + out.push_str(&tag[..insert_at]); + let _ = write!( + out, + r#" {}="{}""#, + attr_name, + escape_svg_attr_value(attr_value) + ); + out.push_str(&tag[insert_at..]); + Some(out) +} + +fn escape_svg_attr_value(value: &str) -> String { + let mut out = String::with_capacity(value.len()); + for ch in value.chars() { + match ch { + '&' => out.push_str("&"), + '"' => out.push_str("""), + '<' => out.push_str("<"), + '>' => out.push_str(">"), + _ => out.push(ch), + } + } + out +} + +#[cfg(test)] +mod tests { + use super::*; + + fn template_json(rule_entries: &str) -> String { + format!( + r#"{{ + "schema_version": 1, + "entries": [ + {rule_entries} + ] +}}"# + ) + } + + #[test] + fn renders_proof_as_typst_svg() { + if std::process::Command::new("typst") + .arg("--version") + .status() + .is_err() + { + eprintln!("skipping proof svg render test because `typst` CLI is unavailable"); + return; + } + + let index = ProofRulesTemplateIndex::from_json_str(&template_json( + r#"{ + "id": "src_test_rs__1_1__MulPat", + "display_name": "MulPat", + "rule_name": "MulPat", + "file": "src/test.rs", + "line": 1, + "column": 1, + "ok": true, + "pattern": { + "math_view": { + "formula_source": { + "plain": "upright(\"ProofMul\")(l, r) arrow.r.double upright(\"ProofConst\")(l * r)" + } + } + } + }"#, + )) + .expect("template should parse"); + + let svg = render_proof_text_svg( + "(Rule (= (ProofMul 3 2) (ProofConst 6)) (name \"@MulPat\") (premises) (substitution))", + &index, + ) + .expect("proof svg should render"); + + assert!(svg.contains("") + .expect("first step detail should be anchored"); + let step2_anchor_idx = typst + .rfind("") + .expect("second step detail should be anchored"); + + assert!(typst.contains(r##"#link()["##)); + assert!(typst.contains(r##"#link()["##)); + assert!(state0_idx < state1_idx); + assert!(state1_idx < state2_idx); + assert!(state2_idx < step1_anchor_idx); + assert!(step1_anchor_idx < step2_anchor_idx); + assert!(typst.find("ConstPropMulPat").unwrap() > state2_idx); + assert!(typst.find("ConstPropAddPat").unwrap() > state2_idx); + assert!(typst.contains("$3 * 2 arrow.r.double 6$")); + assert!(typst.contains("$6 + 4 arrow.r.double 10$")); + assert!(!typst.contains("↓")); + assert!(!typst.contains("Prop 0")); + } + + #[test] + fn concise_svg_postprocess_makes_highlight_labels_clickable() { + let svg = r##" + + + + + + +"##; + let processed = inject_concise_proof_svg_links(svg); + let link_idx = processed + .find(r##"")); + } + + #[test] + fn prefers_semantic_rule_variable_labels_over_internal_expr_names() { + let index = ProofRulesTemplateIndex::from_json_str(&template_json( + r#"{ + "id": "src_test_rs__1_1__ConstPropAddPat", + "display_name": "ConstPropAddPat", + "rule_name": "ConstPropAddPat", + "file": "src/test.rs", + "line": 1, + "column": 1, + "ok": true, + "pattern": { + "typst_templates": [ + { + "variant_name": "Const", + "template": "{num}", + "fields": ["num"] + }, + { + "variant_name": "Mul", + "template": "{lhs} * {rhs}", + "fields": ["lhs", "rhs"] + }, + { + "variant_name": "Add", + "template": "{lhs} + {rhs}", + "fields": ["lhs", "rhs"] + } + ], + "precedence_templates": [ + { + "variant_name": "Const", + "precedence": 100 + }, + { + "variant_name": "Mul", + "precedence": 20 + }, + { + "variant_name": "Add", + "precedence": 10 + } + ], + "math_view": { + "premises": [ + { + "target_id": "l", + "label": "l: Const", + "plain_source": "l", + "colored_source": "l" + }, + { + "target_id": "r", + "label": "r: Const", + "plain_source": "r", + "colored_source": "r" + }, + { + "target_id": "p", + "label": "p: Add", + "plain_source": "upright(\"Add\")(l, r)", + "colored_source": "upright(\"Add\")(l, r)" + } + ], + "formula_source": { + "plain": "frac(l \\ r \\ upright(\"Add\")(l, r), upright(\"Add\")(l, r) arrow.r.double upright(\"Const\")(upright(\"cal\")))" + } + } + } + }"#, + )) + .expect("template should parse"); + + let typst = render_proof_text_typst( + r#"(let t0 (Mul (Const 3) (Const 2))) +(let t1 (Add t0 (Const 4))) +(Rule (= (Const 10) t1) + (name "@ConstPropAddPat") + (premises) + (substitution + (expr9 t1) + (expr8 (Const 4)) + (expr7num 6) + (expr7 t0) + (expr8num 4)))"#, + &index, + ); + + assert!(typst.contains("l =")); + assert!(typst.contains("r =")); + assert!(typst.contains("p =")); + assert!(!typst.contains("expr7num")); + assert!(!typst.contains("expr8num")); + } +} diff --git a/src/wrap/rule.rs b/src/wrap/rule.rs index 2f27747..2f4c2e7 100644 --- a/src/wrap/rule.rs +++ b/src/wrap/rule.rs @@ -1,6 +1,7 @@ use crate::wrap::{ - self, BoxedContainer, BoxedValue, EgglogContainerTy, EgglogEnumVariantTy, EgglogNode, - Insertable, IntoConstraintFact, PatRecSgl, RetypeValue, + self, BoxedContainer, BoxedValue, EGGPLANT_TIMESTAMP_COUNTER_FUNCTION, EgglogContainerTy, + EgglogEnumVariantTy, EgglogNode, FunctionId, Insertable, IntoConstraintFact, PatRecSgl, + RetypeValue, eggplant_timestamp_function_name, }; use crate::wrap::{BoxedBase, EgglogTy, NodeDropperSgl, PatVars, WithPatRecSgl}; use egglog::ContainerValue; @@ -14,42 +15,23 @@ use egglog::{ }; use egglog_reports::RunReport; use serde::{Deserialize, Serialize}; -use std::cell::{RefCell, UnsafeCell}; +use std::cell::UnsafeCell; use std::collections::{HashMap, HashSet}; use std::marker::PhantomData; use std::ops::Deref; use std::panic::Location; use std::path::{Path, PathBuf}; -use std::sync::Arc; -use std::sync::{Mutex, OnceLock}; +use std::sync::atomic::{AtomicUsize, Ordering}; +use std::sync::{Arc, Mutex, OnceLock}; use wrap::Value; -pub(crate) fn empty_premise_proofs() -> Arc<[egglog::Value]> { - static EMPTY: std::sync::OnceLock> = std::sync::OnceLock::new(); - Arc::clone(EMPTY.get_or_init(|| Arc::from(Vec::::new().into_boxed_slice()))) -} - thread_local! { - pub(crate) static CURRENT_PREMISE_PROOFS: RefCell>> = RefCell::new(Vec::new()); - static CURRENT_ACTION_EFFECT_ID: RefCell> = const { RefCell::new(None) }; + static CURRENT_ACTION_EFFECT_ID: std::cell::RefCell> = const { + std::cell::RefCell::new(None) + }; } -pub(crate) struct PremiseProofScope; - -impl PremiseProofScope { - pub(crate) fn enter(premise_proofs: Arc<[egglog::Value]>) -> Self { - CURRENT_PREMISE_PROOFS.with(|cell| cell.borrow_mut().push(premise_proofs)); - PremiseProofScope - } -} - -impl Drop for PremiseProofScope { - fn drop(&mut self) { - CURRENT_PREMISE_PROOFS.with(|cell| { - let _ = cell.borrow_mut().pop(); - }); - } -} +static NEXT_TIMESTAMP_COUNTER: AtomicUsize = AtomicUsize::new(1); // eggplant rule context is a wrapper of egglog rule context. // it contains the Tx to which the rule is applied @@ -58,7 +40,8 @@ pub struct PRRuleCtx<'a, 'b, 'c, 'p, PR: PatRecSgl> { _p: PhantomData, } pub struct RuleCtx<'a, 'b, 'c, 'p> { - pub rule_ctx: UnsafeCell<&'c mut RustRuleContext<'a, 'b, 'p>>, + pub rule_ctx: UnsafeCell<&'c mut RustRuleContext<'a, 'b>>, + _p: PhantomData<&'p ()>, hook: RuleHookObj, } unsafe impl Send for RuleHookObj {} @@ -334,7 +317,7 @@ fn scan_action_call_end(text: &str, start: usize) -> Option { } impl<'a, 'b, 'c, 'p, PR: PatRecSgl> PRRuleCtx<'a, 'b, 'c, 'p, PR> { - pub fn new(rule_ctx: &'c mut RustRuleContext<'a, 'b, 'p>, hook: RuleHookObj) -> Self { + pub fn new(rule_ctx: &'c mut RustRuleContext<'a, 'b>, hook: RuleHookObj) -> Self { Self { _p: PhantomData::default(), ctx: RuleCtx::new(rule_ctx, hook), @@ -413,9 +396,10 @@ impl<'a, 'b, 'c, 'p, PR: PatRecSgl> PRRuleCtx<'a, 'b, 'c, 'p, PR> { } } impl<'a, 'b, 'c, 'p> RuleCtx<'a, 'b, 'c, 'p> { - pub fn new(egglog_ctx: &'c mut RustRuleContext<'a, 'b, 'p>, hook: RuleHookObj) -> Self { + pub fn new(egglog_ctx: &'c mut RustRuleContext<'a, 'b>, hook: RuleHookObj) -> Self { RuleCtx { rule_ctx: UnsafeCell::new(egglog_ctx), + _p: PhantomData::default(), hook, } } @@ -443,12 +427,8 @@ impl<'a, 'b, 'c, 'p> RuleCtx<'a, 'b, 'c, 'p> { fn _intern_container(&self, container: C) -> egglog::Value { unsafe { (*self.rule_ctx.get()).container_to_value(container) } } - fn cached_function_id( - &self, - table: &'static str, - cached: &OnceLock, - ) -> egglog::FunctionId { - *cached.get_or_init(|| unsafe { (*self.rule_ctx.get()).function_id(table) }) + fn cached_function_id(&self, table: &'static str, cached: &OnceLock) -> FunctionId { + cached.get_or_init(|| table.to_string()).clone() } pub fn insert(&self, table: &str, key: &[egglog::Value]) -> egglog::Value { self.lookup_expect(table, key) @@ -457,7 +437,7 @@ impl<'a, 'b, 'c, 'p> RuleCtx<'a, 'b, 'c, 'p> { pub fn insert_cached( &self, table: &'static str, - cached: &OnceLock, + cached: &OnceLock, key: &[egglog::Value], ) -> egglog::Value { self.lookup_expect_cached(table, cached, key) @@ -485,21 +465,22 @@ note: `ctx.set_*` uses staged insert (`insert_func_tbl`) so rows may not be visi pub fn lookup_cached( &self, table: &'static str, - cached: &OnceLock, + cached: &OnceLock, key: &[egglog::Value], ) -> Option { if let Some(hook) = self.hook.0.as_ref() { let _effect_scope = ActionEffectScope::enter(Location::caller()); hook.on_insert(table, key); } - let table_id = self.cached_function_id(table, cached); - unsafe { (*self.rule_ctx.get()).lookup_id(table_id, key) } + let table_name = self.cached_function_id(table, cached); + unsafe { (*self.rule_ctx.get()).lookup(&table_name, key) } } + // ! 这个函数应该被删掉， 因为已经没有 ctx.read_func 这种用法了，它被ban 了 #[track_caller] pub fn lookup_expect_cached( &self, table: &'static str, - cached: &OnceLock, + cached: &OnceLock, key: &[egglog::Value], ) -> egglog::Value { self.lookup_cached(table, cached, key).unwrap_or_else(|| { @@ -523,15 +504,25 @@ note: `ctx.set_*` uses staged insert (`insert_func_tbl`) so rows may not be visi pub fn insert_func_tbl_cached( &self, table: &'static str, - cached: &OnceLock, + cached: &OnceLock, key: &[egglog::Value], ) { if let Some(hook) = self.hook.0.as_ref() { let _effect_scope = ActionEffectScope::enter(Location::caller()); hook.on_insert(table, key); } - let table_id = self.cached_function_id(table, cached); - unsafe { (*self.rule_ctx.get()).insert_id(table_id, key.iter().cloned()) } + let table_name = self.cached_function_id(table, cached); + unsafe { (*self.rule_ctx.get()).insert(&table_name, key.iter().cloned()) } + } + pub fn insert_timestamp_for_value(&self, sort_name: &str, value: egglog::Value) { + let current_ts = NEXT_TIMESTAMP_COUNTER.fetch_add(1, Ordering::Relaxed) as i64; + let current = self._intern_base::(current_ts); + self.insert_func_tbl( + &eggplant_timestamp_function_name(sort_name), + &[value, current], + ); + let next = self._intern_base::(current_ts.saturating_add(1)); + self.insert_func_tbl(EGGPLANT_TIMESTAMP_COUNTER_FUNCTION, &[next]); } pub fn union( &self, @@ -544,19 +535,7 @@ note: `ctx.set_*` uses staged insert (`insert_func_tbl`) so rows may not be visi hook.on_union(x.val, y.val); } unsafe { - CURRENT_PREMISE_PROOFS.with(|cell| { - let premise_proofs_stack = cell.borrow(); - if let Some(premise_proofs) = premise_proofs_stack.last() { - (*self.rule_ctx.get()).union_typed( - T0::TY_NAME, - x.val, - y.val, - premise_proofs.as_ref(), - ); - } else { - (*self.rule_ctx.get()).union(x.val, y.val); - } - }); + (*self.rule_ctx.get()).union_typed(T0::TY_NAME, x.val, y.val); } } #[track_caller] @@ -597,6 +576,11 @@ pub trait RuleRunner { ); fn new_ruleset(&self, rule_set: &'static str) -> RuleSetId; fn run_ruleset(&self, rule_set_id: RuleSetId, run_config: RunConfig) -> RunReport; + fn run_schedule(&self, schedule: impl Into) -> RunReport { + schedule + .into() + .execute_with(|ruleset| self.run_ruleset(ruleset, RunConfig::Once)) + } fn value(&self, node: &T) -> Value; } pub trait RuleRunnerSgl: WithPatRecSgl + NodeDropperSgl { @@ -626,6 +610,11 @@ pub trait RuleRunnerSgl: WithPatRecSgl + NodeDropperSgl { ); fn new_ruleset(rule_set: &'static str) -> RuleSetId; fn run_ruleset(rule_set_id: RuleSetId, run_config: RunConfig) -> RunReport; + fn run_schedule(schedule: impl Into) -> RunReport { + schedule + .into() + .execute_with(|ruleset| Self::run_ruleset(ruleset, RunConfig::Once)) + } fn value(node: &T) -> Value; } impl RuleRunnerSgl for T @@ -653,15 +642,166 @@ where } } -#[derive(Clone, Copy)] +#[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct RuleSetId(pub &'static str); +#[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum RunConfig { Sat, Times(u32), Once, } +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum RunSchedule { + Run(RuleSetId), + Sequence(Vec), + Repeat { + times: u32, + schedule: Box, + }, + Saturate(Box), +} + +impl RunSchedule { + pub fn builder() -> RunScheduleBuilder { + RunScheduleBuilder::new() + } + + pub fn run(ruleset: RuleSetId) -> Self { + Self::Run(ruleset) + } + + pub fn from_ruleset_config(ruleset: RuleSetId, config: RunConfig) -> Self { + match config { + RunConfig::Once => Self::run(ruleset), + RunConfig::Times(times) => Self::repeat(times, Self::run(ruleset)), + RunConfig::Sat => Self::saturate(Self::run(ruleset)), + } + } + + pub fn seq(items: impl IntoIterator) -> Self { + Self::Sequence(items.into_iter().collect()) + } + + pub fn repeat(times: u32, schedule: impl Into) -> Self { + Self::Repeat { + times, + schedule: Box::new(schedule.into()), + } + } + + pub fn saturate(schedule: impl Into) -> Self { + Self::Saturate(Box::new(schedule.into())) + } + + pub fn execute_with(&self, mut run_once: impl FnMut(RuleSetId) -> RunReport) -> RunReport { + self.execute_with_ref(&mut run_once) + } + + fn execute_with_ref(&self, run_once: &mut impl FnMut(RuleSetId) -> RunReport) -> RunReport { + match self { + RunSchedule::Run(ruleset) => run_once(*ruleset), + RunSchedule::Sequence(schedules) => { + let mut report = RunReport::default(); + for schedule in schedules { + report.union(schedule.execute_with_ref(run_once)); + } + report + } + RunSchedule::Repeat { times, schedule } => { + let mut report = RunReport::default(); + for _ in 0..*times { + let iter_report = schedule.execute_with_ref(run_once); + let updated = iter_report.updated; + report.union(iter_report); + if !updated { + break; + } + } + report + } + RunSchedule::Saturate(schedule) => { + let mut report = RunReport::default(); + loop { + let iter_report = schedule.execute_with_ref(run_once); + let updated = iter_report.updated; + report.union(iter_report); + if !updated { + break report; + } + } + } + } + } +} + +impl From for RunSchedule { + fn from(ruleset: RuleSetId) -> Self { + Self::run(ruleset) + } +} + +#[derive(Debug, Clone, Default, PartialEq, Eq)] +pub struct RunScheduleBuilder { + schedules: Vec, +} + +impl RunScheduleBuilder { + pub fn new() -> Self { + Self::default() + } + + pub fn run(mut self, ruleset: RuleSetId) -> Self { + self.schedules.push(RunSchedule::run(ruleset)); + self + } + + pub fn run_with(mut self, ruleset: RuleSetId, config: RunConfig) -> Self { + self.schedules + .push(RunSchedule::from_ruleset_config(ruleset, config)); + self + } + + pub fn then(mut self, schedule: impl Into) -> Self { + self.schedules.push(schedule.into()); + self + } + + pub fn repeat( + mut self, + times: u32, + build: impl FnOnce(RunScheduleBuilder) -> RunScheduleBuilder, + ) -> Self { + self.schedules + .push(RunSchedule::repeat(times, build(Self::new()).build())); + self + } + + pub fn repeat_schedule(mut self, times: u32, schedule: impl Into) -> Self { + self.schedules.push(RunSchedule::repeat(times, schedule)); + self + } + + pub fn saturate(mut self, ruleset: RuleSetId) -> Self { + self.schedules.push(RunSchedule::saturate(ruleset)); + self + } + + pub fn saturate_schedule(mut self, schedule: impl Into) -> Self { + self.schedules.push(RunSchedule::saturate(schedule)); + self + } + + pub fn build(self) -> RunSchedule { + match self.schedules.len() { + 0 => RunSchedule::Sequence(Vec::new()), + 1 => self.schedules.into_iter().next().unwrap(), + _ => RunSchedule::Sequence(self.schedules), + } + } +} + pub struct FactsBuilder { table_facts: Vec, constraint_facts: Vec>, diff --git a/src/wrap/type_reg.rs b/src/wrap/type_reg.rs index 2b83f4a..d5b8d6d 100644 --- a/src/wrap/type_reg.rs +++ b/src/wrap/type_reg.rs @@ -1,4 +1,4 @@ -use std::collections::HashMap; +use std::collections::{BTreeSet, HashMap}; use std::fmt::Debug; use std::hash::Hash; use std::marker::PhantomData; @@ -68,6 +68,29 @@ pub trait EgglogTy: 'static { .clone() } } + +pub const EGGPLANT_TIMESTAMP_FUNCTION_PREFIX: &str = "__eggplant_timestamp_"; +pub const EGGPLANT_TIMESTAMP_COUNTER_FUNCTION: &str = "__eggplant_timestamp_counter"; + +pub fn eggplant_timestamp_function_name(sort_name: &str) -> String { + let escaped = sort_name + .chars() + .map(|ch| { + if ch.is_ascii_alphanumeric() || ch == '_' { + ch + } else { + '_' + } + }) + .collect::(); + format!("{EGGPLANT_TIMESTAMP_FUNCTION_PREFIX}{escaped}") +} + +pub fn is_eggplant_timestamp_function(function_name: &str) -> bool { + function_name == EGGPLANT_TIMESTAMP_COUNTER_FUNCTION + || function_name.starts_with(EGGPLANT_TIMESTAMP_FUNCTION_PREFIX) +} + impl PatVars for T where T::Valued: crate::wrap::DecodeWithPlanMetas, @@ -139,7 +162,7 @@ pub trait PersistedSnapshotUserBaseSortHook: Send + Sync { ) -> Option; fn restore_machine_value( &self, - ctx: &mut egglog::prelude::RustRuleContext<'_, '_, '_>, + ctx: &mut egglog::prelude::RustRuleContext<'_, '_>, machine_value: &serde_json::Value, ) -> Result; } @@ -191,7 +214,7 @@ where fn restore_machine_value( &self, - ctx: &mut egglog::prelude::RustRuleContext<'_, '_, '_>, + ctx: &mut egglog::prelude::RustRuleContext<'_, '_>, machine_value: &serde_json::Value, ) -> Result { let decoded = @@ -318,6 +341,60 @@ impl EgglogTypeRegistry { } } + // Upstream egglog proof encoding cannot register sorts declared through a presort + // (Set/Vec/Map/etc.), and it also rejects any datatype that depends on one of those + // sorts. We compute that unsupported closure up front so proof-mode registration can + // skip the whole invalid subtree before typechecking runs. + fn collect_unsupported_proof_sorts() -> BTreeSet { + let mut unsupported = BTreeSet::new(); + for decl in inventory::iter:: { + if let Decl::EgglogContainerTy { name, .. } = decl { + unsupported.insert(Self::normalize_ty_name(name)); + } + } + + loop { + let mut changed = false; + for decl in inventory::iter:: { + let Decl::EgglogMultiConTy { name, cons } = decl else { + continue; + }; + let name = Self::normalize_ty_name(name); + if unsupported.contains(&name) { + continue; + } + let depends_on_unsupported = cons.iter().any(|con| { + con.input + .iter() + .map(|ty| Self::normalize_ty_name(ty)) + .any(|ty| unsupported.contains(&ty)) + }); + if depends_on_unsupported { + unsupported.insert(name); + changed = true; + } + } + if !changed { + break; + } + } + + unsupported + } + + fn sort_decl_supported(name: &str, unsupported: &BTreeSet) -> bool { + // Normalize aliases like Q/Z before checking so the filter matches egglog's + // canonical sort names. + !unsupported.contains(&Self::normalize_ty_name(name)) + } + + fn field_types_supported(types: &[&str], unsupported: &BTreeSet) -> bool { + types + .iter() + .map(|ty| Self::normalize_ty_name(ty)) + .all(|ty| !unsupported.contains(&ty)) + } + pub fn new_with_inventory() -> Self { let (enum_node_fns_map, variant2type_map) = Self::collect_enum_fns(); let container_node_fns_map = Self::collect_container_fns(); @@ -363,13 +440,28 @@ impl EgglogTypeRegistry { }); map } - pub fn collect_type_defs() -> Vec { + fn collect_type_defs_impl(proof_mode: bool) -> Vec { let mut commands = vec![]; + let mut timestamp_sorts = BTreeSet::::new(); + // Proof mode registers only the schema that egglog's proof encoder accepts. + // The normal path keeps the full inventory, including container presorts and + // other declarations that proof mode cannot typecheck. + let unsupported_sorts = if proof_mode { + Self::collect_unsupported_proof_sorts() + } else { + BTreeSet::new() + }; // split decls to avoid undefined sort let mut types = Vec::<(Span, String, Subdatatypes)>::new(); for decl in inventory::iter:: { match decl { Decl::EgglogMultiConTy { name, cons } => { + if proof_mode && !Self::sort_decl_supported(name, &unsupported_sorts) { + continue; + } + // Keep only datatypes whose constructors stay entirely inside the + // proof-safe sort subset. + timestamp_sorts.insert(Self::normalize_ty_name(name)); types.push(( span!(), name.to_string(), @@ -397,6 +489,12 @@ impl EgglogTypeRegistry { term_to_node: _, ty_str, } => { + if proof_mode { + // Container sorts are represented as presorts in egglog, and proof + // encoding rejects presort-backed sorts entirely. + continue; + } + timestamp_sorts.insert(Self::normalize_ty_name(name)); let ele_ty = ele_ty_name.to_owned(); let ele = var!(ele_ty); types.push(( @@ -410,11 +508,44 @@ impl EgglogTypeRegistry { } } } - commands.push(Command::Datatypes { + if !types.is_empty() { + commands.push(Command::Datatypes { + span: span!(), + datatypes: types, + }); + } + let mut parser = Parser::default(); + let timestamp_merge = parser + .get_expr_from_string(None, "(max old new)") + .expect("internal timestamp merge expression should parse"); + commands.push(Command::Function { span: span!(), - datatypes: types, + name: EGGPLANT_TIMESTAMP_COUNTER_FUNCTION.to_string(), + schema: Schema { + input: Vec::new(), + output: ::TY_NAME.to_string(), + }, + merge: Some(timestamp_merge.clone()), + hidden: true, + let_binding: false, + term_constructor: None, + unextractable: false, }); - let mut parser = Parser::default(); + for sort_name in timestamp_sorts { + commands.push(Command::Function { + span: span!(), + name: eggplant_timestamp_function_name(&sort_name), + schema: Schema { + input: vec![sort_name], + output: ::TY_NAME.to_string(), + }, + merge: Some(timestamp_merge.clone()), + hidden: true, + let_binding: false, + term_constructor: None, + unextractable: false, + }); + } for decl in inventory::iter:: { match decl { Decl::EgglogFuncTy { @@ -426,6 +557,16 @@ impl EgglogTypeRegistry { let_binding, .. } => { + if proof_mode + && (merge.is_none() + || !Self::field_types_supported(input, &unsupported_sorts) + || !Self::sort_decl_supported(output, &unsupported_sorts)) + { + // Proof mode requires a merge function for every non-global + // function, and all argument / result sorts must already be in the + // proof-safe subset. + continue; + } commands.push(Command::Function { span: span!(), name: name.to_string(), @@ -440,9 +581,16 @@ impl EgglogTypeRegistry { }), hidden: *hidden, let_binding: *let_binding, + term_constructor: None, + unextractable: false, }); } Decl::EgglogRelationTy { name, input, .. } => { + if proof_mode && !Self::field_types_supported(input, &unsupported_sorts) { + // Relations are only safe to register if every field sort survives + // the proof-mode filter above. + continue; + } commands.push(Command::Relation { span: span!(), name: name.to_string(), @@ -455,6 +603,19 @@ impl EgglogTypeRegistry { commands } + /// Build the full schema for normal eggplant execution. + pub fn collect_type_defs() -> Vec { + Self::collect_type_defs_impl(false) + } + + /// Build the proof-safe schema subset for `EGraph::new_with_proofs`. + /// + /// This is a compatibility filter for upstream egglog proof encoding; it does not + /// mean eggplant has full proof support for every schema shape. + pub fn collect_type_defs_for_proofs() -> Vec { + Self::collect_type_defs_impl(true) + } + pub fn variant_to_type_name(&self, variant_name: &str) -> Option<&'static str> { self.variant2type_map.get(variant_name).copied() } diff --git a/src/wrap/wrap.rs b/src/wrap/wrap.rs index a9f460f..7f5d6d0 100644 --- a/src/wrap/wrap.rs +++ b/src/wrap/wrap.rs @@ -1,6 +1,12 @@ use crate::prelude::slotted::{_FuncValueMeta, FuncName, FuncValueMeta}; use crate::prelude::{SlotMeta, TxRxVT}; +use crate::wrap::DslVariantDecl; use crate::wrap::constraint::IntoConstraintFact; +#[cfg(feature = "rustsat-extract")] +use crate::wrap::eboost_extract::{ + EBoostCandidate, EBoostEqKey, EBoostPrepared, collect_candidates, prepare_eboost_candidates, +}; +use crate::wrap::eboost_extract::{EBoostExtractConfig, eboost_extract_value_prototype}; use crate::wrap::{ EValue, EgglogFunc, EgglogFuncInputs, EgglogFuncInputsRef, EgglogFuncOutput, EgglogRelation, EgglogTy, FactsBuilder, FromBase, SortName, SymLit, TableName, VarName, @@ -12,10 +18,10 @@ use egglog::ast::{RustSpan, Span}; use egglog::extract::{CostModel, DefaultCost, TreeAdditiveCostModel}; use egglog::prelude::span; use egglog::{ - ArcSort, BaseValue, ContainerValue, EGraph, SchemaFunctionKind, SerializeConfig, + ArcSort, BaseValue, ContainerValue, EGraph, ast::{Command, GenericAction, GenericExpr}, }; -use egglog::{TermDag, TermId, ast::Literal}; +use egglog::{Term, TermDag, TermId, ast::Literal}; #[cfg(feature = "rustsat-extract")] use rustsat::{ algs::maxsat::SolutionImprovingSearch, @@ -29,18 +35,22 @@ use rustsat::{ use rustsat_minisat::core::Minisat as RustsatMinisat; use serde::{Deserialize, Serialize}; use smallvec::SmallVec; +#[cfg(feature = "rustsat-extract")] +use std::collections::{BTreeSet, HashSet, VecDeque}; use std::sync::Mutex; use std::{ any::Any, borrow::Borrow, borrow::Cow, - collections::{BTreeSet, HashMap, HashSet, VecDeque}, - fmt, + collections::HashMap, + fmt, fs, hash::Hash, marker::PhantomData, panic::Location, path::Path, + process::Command as ProcessCommand, sync::{Arc, atomic::AtomicU32}, + time::{SystemTime, UNIX_EPOCH}, }; use strum::IntoDiscriminant; use strum_macros::{EnumDiscriminants, EnumIs}; @@ -784,6 +794,131 @@ pub fn render_variant_display( .map(|template| render_template_with_precedence(template, V::PRECEDENCE, fields)) } +fn dsl_variant_decl(variant_name: &str) -> Option<&'static DslVariantDecl> { + inventory::iter:: + .into_iter() + .find(|decl| decl.variant_name == variant_name) +} + +fn literal_to_typst(literal: &Literal) -> String { + match literal { + Literal::Int(n) => n.to_string(), + Literal::Float(n) => n.to_string(), + Literal::String(s) => { + if s.chars().count() == 1 { + s.clone() + } else { + format!("\"{s}\"") + } + } + Literal::Bool(b) => b.to_string(), + Literal::Unit => "()".to_string(), + } +} + +fn render_term_to_typst( + term_id: TermId, + term_dag: &TermDag, +) -> Result, egglog::Error> { + match term_dag.get(term_id) { + Term::Lit(literal) => Ok(RenderedTemplateField::atom(literal_to_typst(literal))), + Term::Var(name) => Ok(RenderedTemplateField::atom(name.clone())), + Term::App(name, children) => { + let decl = dsl_variant_decl(name.as_str()).ok_or_else(|| { + egglog::Error::BackendError(format!( + "missing DslVariantDecl metadata for extracted variant `{name}`" + )) + })?; + let typst_template = decl.typst_template.ok_or_else(|| { + egglog::Error::BackendError(format!( + "variant `{name}` does not provide a #[typst(...)] template" + )) + })?; + if decl.fields.len() != children.len() { + return Err(egglog::Error::BackendError(format!( + "variant `{name}` field count does not match extracted term arity" + ))); + } + + let mut rendered_fields = Vec::with_capacity(children.len()); + for (field, child_term) in decl.fields.iter().zip(children.iter()) { + rendered_fields.push((field.name, render_term_to_typst(*child_term, term_dag)?)); + } + + Ok(RenderedTemplateField::new( + render_template_with_precedence(typst_template, decl.precedence, &rendered_fields), + decl.precedence, + )) + } + } +} + +pub fn compile_typst_document_to_svg( + typst_source: &str, + output_path: &Path, +) -> Result<(), egglog::Error> { + let unique = SystemTime::now() + .duration_since(UNIX_EPOCH) + .map_err(|err| egglog::Error::BackendError(format!("system clock error: {err}")))? + .as_nanos(); + let input_path = std::env::temp_dir().join(format!("eggplant_typst_render_{unique}.typ")); + fs::write(&input_path, typst_source).map_err(|err| { + egglog::Error::BackendError(format!( + "failed to write temporary typst source `{}`: {err}", + input_path.display() + )) + })?; + + let output = ProcessCommand::new("typst") + .arg("compile") + .arg(&input_path) + .arg(output_path) + .output() + .map_err(|err| { + egglog::Error::BackendError(format!("failed to invoke `typst compile`: {err}")) + })?; + + let _ = fs::remove_file(&input_path); + + if !output.status.success() { + return Err(egglog::Error::BackendError(format!( + "`typst compile` failed: {}", + String::from_utf8_lossy(&output.stderr) + ))); + } + + Ok(()) +} + +pub fn compile_typst_document_to_svg_string(typst_source: &str) -> Result { + let unique = SystemTime::now() + .duration_since(UNIX_EPOCH) + .map_err(|err| egglog::Error::BackendError(format!("system clock error: {err}")))? + .as_nanos(); + let output_path = std::env::temp_dir().join(format!("eggplant_typst_render_{unique}.svg")); + let result = compile_typst_document_to_svg(typst_source, &output_path).and_then(|_| { + fs::read_to_string(&output_path).map_err(|err| { + egglog::Error::BackendError(format!( + "failed to read temporary typst output `{}`: {err}", + output_path.display() + )) + }) + }); + let _ = fs::remove_file(&output_path); + result +} + +pub fn compile_typst_math_to_svg( + typst_math: &str, + output_path: &Path, +) -> Result<(), egglog::Error> { + let document = format!( + "#set page(width: auto, height: auto, margin: 8pt)\n#set text(size: 14pt)\n${}$\n", + typst_math + ); + compile_typst_document_to_svg(&document, output_path) +} + #[derive(DerefMut, Deref)] pub struct WorkAreaNode { pub next: Option, @@ -1549,9 +1684,27 @@ impl RustsatExtractConfig { } } +#[derive(Debug, Clone)] +pub struct EBoostLayeredConfig { + pub bound: f32, + pub exact: RustsatExtractConfig, +} + +impl Default for EBoostLayeredConfig { + fn default() -> Self { + Self { + bound: 1.25, + exact: RustsatExtractConfig::default(), + } + } +} + #[derive(Debug, Clone)] pub enum ExtractBackend { CostModel(CM), + EBoostHeuristic(EBoostExtractConfig), + #[cfg(feature = "rustsat-extract")] + EBoostLayered(EBoostLayeredConfig), #[cfg(feature = "rustsat-extract")] Rustsat(RustsatExtractConfig), } @@ -1561,6 +1714,15 @@ impl ExtractBackend { Self::CostModel(cost_model) } + pub fn eboost_heuristic(config: EBoostExtractConfig) -> Self { + Self::EBoostHeuristic(config) + } + + #[cfg(feature = "rustsat-extract")] + pub fn eboost_layered(config: EBoostLayeredConfig) -> Self { + Self::EBoostLayered(config) + } + #[cfg(feature = "rustsat-extract")] pub fn rustsat(config: RustsatExtractConfig) -> Self { Self::Rustsat(config) @@ -1573,6 +1735,30 @@ impl Default for ExtractBackend { } } +pub fn extract_raw_with_backend + 'static>( + egraph: &EGraph, + sort: &ArcSort, + value: egglog::Value, + backend: ExtractBackend, +) -> Result<(TermDag, TermId, DefaultCost), egglog::Error> { + match backend { + ExtractBackend::CostModel(cost_model) => { + egraph.extract_value_with_cost_model(sort, value, cost_model) + } + ExtractBackend::EBoostHeuristic(config) => { + eboost_extract_value_prototype(egraph, sort, value, config) + } + #[cfg(feature = "rustsat-extract")] + ExtractBackend::EBoostLayered(config) => { + eboost_layered_extract_value_prototype(egraph, sort, value, config) + } + #[cfg(feature = "rustsat-extract")] + ExtractBackend::Rustsat(config) => { + rustsat_extract_value_prototype(egraph, sort, value, config) + } + } +} + pub trait ExtractSgl: NonPatRecSgl { fn extract_value( value: Value, @@ -1593,27 +1779,11 @@ pub trait ExtractSgl: NonPatRecSgl { fn extract_value_with_backend + 'static>( value: Value, backend: ExtractBackend, - ) -> Result<(TermDag, TermId, DefaultCost), egglog::Error> { - match backend { - ExtractBackend::CostModel(cost_model) => { - Self::extract_value_with_cost_model(value, cost_model) - } - #[cfg(feature = "rustsat-extract")] - ExtractBackend::Rustsat(config) => { - Self::extract_value_with_rustsat_config(value, config) - } - } - } - - #[cfg(feature = "rustsat-extract")] - fn extract_value_with_rustsat_config( - value: Value, - config: RustsatExtractConfig, ) -> Result<(TermDag, TermId, DefaultCost), egglog::Error> { let egraph = Self::egraph(); let egraph = egraph.lock().unwrap(); let sort = T::get_arc_sort(&egraph); - rustsat_extract_value_prototype(&egraph, &sort, value.val, config) + extract_raw_with_backend(&egraph, &sort, value.val, backend) } fn extract_value_to_string( @@ -1707,6 +1877,33 @@ pub trait ExtractNodeSgl: ExtractSgl + TxSgl { backend, ) } + + fn extract_node_to_typst_with_backend( + node: &N, + backend: ExtractBackend, + ) -> Result<(String, DefaultCost), egglog::Error> + where + N: EgglogNode + EgglogTy + 'static, + CM: CostModel + 'static, + { + let (termdag, term, cost) = Self::extract_node_with_backend(node, backend)?; + let rendered = render_term_to_typst(term, &termdag)?.text.into_owned(); + Ok((rendered, cost)) + } + + fn extract_node_to_svg_with_backend( + node: &N, + backend: ExtractBackend, + output_path: impl AsRef, + ) -> Result + where + N: EgglogNode + EgglogTy + 'static, + CM: CostModel + 'static, + { + let (typst, cost) = Self::extract_node_to_typst_with_backend(node, backend)?; + compile_typst_math_to_svg(&typst, output_path.as_ref())?; + Ok(cost) + } } impl ExtractNodeSgl for T {} @@ -1746,6 +1943,16 @@ impl RustsatCandidateDraft { } } +#[cfg(feature = "rustsat-extract")] +impl From<&EBoostEqKey> for RustsatEqKey { + fn from(value: &EBoostEqKey) -> Self { + Self { + sort_name: value.sort_name.clone(), + value: value.value, + } + } +} + #[cfg(feature = "rustsat-extract")] impl RustsatCandidate { fn decode_key(&self) -> String { @@ -1781,6 +1988,15 @@ fn rustsat_extract_value_prototype( }; let draft_candidates = rustsat_collect_draft_candidates(egraph)?; + rustsat_extract_from_drafts(egraph, root_key, draft_candidates) +} + +#[cfg(feature = "rustsat-extract")] +fn rustsat_extract_from_drafts( + egraph: &EGraph, + root_key: RustsatEqKey, + draft_candidates: Vec, +) -> Result<(TermDag, TermId, DefaultCost), egglog::Error> { let draft_by_output = rustsat_index_draft_candidates(&draft_candidates); let reachable_classes = rustsat_collect_reachable_classes(&root_key, &draft_candidates, &draft_by_output)?; @@ -1881,89 +2097,93 @@ fn rustsat_extract_value_prototype( } #[cfg(feature = "rustsat-extract")] -fn rustsat_collect_draft_candidates( +fn eboost_layered_extract_value_prototype( egraph: &EGraph, -) -> Result, egglog::Error> { - let raw_rows = egraph.serialize_raw(SerializeConfig::default()); - let mut functions = egraph - .schema_manifest() - .functions - .into_iter() - .map(|function| (function.name.clone(), function)) - .collect::>(); - let mut out = Vec::new(); - - for (func_name, rows) in raw_rows { - let Some(function_manifest) = functions.remove(&func_name) else { - continue; - }; - if function_manifest.kind != SchemaFunctionKind::Constructor - || function_manifest.hidden - || function_manifest.unextractable - { - continue; - } - if function_manifest.term_constructor.is_some() { - return Err(egglog::Error::BackendError(format!( - "rustsat extraction prototype does not yet support view-table / term-constructor extraction (`{func_name}`); that stays blocked on the broader core work" - ))); - } - - let function = egraph.get_function(&func_name).ok_or_else(|| { - egglog::Error::BackendError(format!( - "schema_manifest listed function `{func_name}` but EGraph::get_function could not find it" - )) - })?; - let output_sort = function.schema().output.clone(); - if !output_sort.is_eq_sort() { - continue; - } - - for row in rows.into_iter().filter(|row| !row.subsumed) { - if row.inputs_complex.len() != function.schema().input.len() { - return Err(egglog::Error::BackendError(format!( - "row/schema arity mismatch while collecting rustsat candidates for `{func_name}`" - ))); - } + sort: &ArcSort, + value: egglog::Value, + config: EBoostLayeredConfig, +) -> Result<(TermDag, TermId, DefaultCost), egglog::Error> { + if !(config.bound.is_finite() && config.bound >= 1.0) { + return Err(egglog::Error::BackendError(format!( + "eboost layered extraction requires bound >= 1.0, got {}", + config.bound + ))); + } + let prepared = prepare_eboost_candidates(egraph, sort, value)?; + let pruned = eboost_layered_prune_candidates(&prepared, config.bound); + let drafts = pruned + .iter() + .map(rustsat_draft_from_eboost_candidate) + .collect::, _>>()?; + rustsat_extract_from_drafts(egraph, RustsatEqKey::from(&prepared.root_key), drafts) +} - let output_value = egraph.get_canonical_value(row.output, &output_sort); - let mut inputs = Vec::with_capacity(row.inputs_complex.len()); - for (raw_value, input_sort) in row - .inputs_complex - .iter() - .copied() - .zip(function.schema().input.iter()) - { - if input_sort.is_container_sort() { - return Err(egglog::Error::BackendError(format!( - "rustsat extraction prototype does not yet support container children (hit in `{func_name}`); keep this out of the first demo and broader prototype until the core is widened" - ))); +#[cfg(feature = "rustsat-extract")] +fn eboost_layered_prune_candidates(prepared: &EBoostPrepared, bound: f32) -> Vec { + let heuristic_choice_ids = prepared + .best_by_class + .values() + .map(|cost_set| cost_set.candidate_idx) + .collect::>(); + + let mut min_score_by_class = HashMap::::new(); + for (idx, score) in &prepared.candidate_scores { + let class_key = prepared.reachable_candidates[*idx].output.clone(); + min_score_by_class + .entry(class_key) + .and_modify(|existing| { + if *score < *existing { + *existing = *score; } - let canonical_value = if input_sort.is_eq_sort() { - egraph.get_canonical_value(raw_value, input_sort) - } else { - raw_value - }; - inputs.push((input_sort.clone(), canonical_value)); + }) + .or_insert(*score); + } + + prepared + .reachable_candidates + .iter() + .enumerate() + .filter(|(idx, candidate)| { + if heuristic_choice_ids.contains(idx) { + return true; } + let Some(score) = prepared.candidate_scores.get(idx) else { + return true; + }; + let Some(class_min) = min_score_by_class.get(&candidate.output) else { + return true; + }; + (*score as f64) <= (*class_min as f64) * (bound as f64) + }) + .map(|(_, candidate)| candidate.clone()) + .collect() +} - out.push(RustsatCandidateDraft { - term_name: func_name.clone(), - output: RustsatEqKey { - sort_name: output_sort.name().to_string(), - value: output_value, - }, - inputs, - penalty: usize::try_from(function_manifest.cost.unwrap_or(1)).map_err(|_| { - egglog::Error::BackendError(format!( - "cost for `{func_name}` does not fit into rustsat weight domain" - )) - })?, - }); - } - } +#[cfg(feature = "rustsat-extract")] +fn rustsat_draft_from_eboost_candidate( + candidate: &EBoostCandidate, +) -> Result { + Ok(RustsatCandidateDraft { + term_name: candidate.term_name.clone(), + output: RustsatEqKey::from(&candidate.output), + inputs: candidate.inputs.clone(), + penalty: usize::try_from(candidate.head_cost).map_err(|_| { + egglog::Error::BackendError(format!( + "cost for `{}` does not fit into rustsat weight domain", + candidate.term_name + )) + })?, + }) +} - Ok(out) +#[cfg(feature = "rustsat-extract")] +fn rustsat_collect_draft_candidates( + egraph: &EGraph, +) -> Result, egglog::Error> { + collect_candidates(egraph)? + .iter() + .map(rustsat_draft_from_eboost_candidate) + .collect() } #[cfg(feature = "rustsat-extract")] diff --git a/tests/eboost_heuristic_extract.rs b/tests/eboost_heuristic_extract.rs new file mode 100644 index 0000000..0cc333b --- /dev/null +++ b/tests/eboost_heuristic_extract.rs @@ -0,0 +1,218 @@ +use eggplant::{prelude::*, tx_rx_vt_pr}; + +#[eggplant::dsl] +enum EBoostExpr { + Leaf { + n: i64, + }, + #[cost(0)] + CheapWrap { + inner: EBoostExpr, + }, + #[cost(5)] + ExpensiveWrap { + inner: EBoostExpr, + }, +} + +tx_rx_vt_pr!(EBoostDemoTx, EBoostDemoPatRec); + +#[eggplant::dsl] +enum EBoostCycleExpr { + CycleLeaf { + n: i64, + }, + #[cost(10)] + CycleWrap { + inner: EBoostCycleExpr, + }, +} + +tx_rx_vt_pr!(EBoostCycleTx, EBoostCyclePatRec); + +#[eggplant::dsl] +enum EBoostCseExpr { + CLeaf { + n: i64, + }, + CInc { + inner: EBoostCseExpr, + }, + CPair { + lhs: EBoostCseExpr, + rhs: EBoostCseExpr, + }, +} + +tx_rx_vt_pr!(EBoostCseTx, EBoostCsePatRec); + +#[test] +fn eboost_backend_matches_default_on_simple_acyclic_wrapper_expression() { + let _ = env_logger::builder().is_test(true).try_init(); + EBoostDemoTx::sgl().reset_for_bench(); + + let leaf = Leaf::::new(7); + let cheap = CheapWrap::::new(&leaf); + cheap.commit(); + let expensive = ExpensiveWrap::::new(&leaf); + expensive.commit(); + + let ruleset = EBoostDemoTx::new_ruleset("union_wrapper_variants_for_eboost_test"); + EBoostDemoTx::add_rule( + "union_wrapper_variants_for_eboost_test", + ruleset, + || { + let leaf = Leaf::query(); + let cheap = CheapWrap::query(&leaf); + let expensive = ExpensiveWrap::query(&leaf); + #[eggplant::pat_vars_catch] + struct Pat { + cheap: CheapWrap, + expensive: ExpensiveWrap, + } + }, + |ctx, pat| { + ctx.union(pat.cheap, pat.expensive); + }, + ); + EBoostDemoTx::run_ruleset(ruleset, RunConfig::Once); + + let default_result = + EBoostDemoTx::extract_node_to_string(&cheap).expect("default extraction should succeed"); + let eboost_result = EBoostDemoTx::extract_node_to_string_with_backend( + &cheap, + ExtractBackend::::eboost_heuristic( + EBoostExtractConfig::default(), + ), + ) + .expect("eboost backend should succeed on the simple acyclic wrapper case"); + + assert_eq!(eboost_result.0, default_result.0); + assert!(eboost_result.0.contains("CheapWrap")); + assert!( + eboost_result.1 <= default_result.1, + "eboost heuristic should not report a higher cost than the legacy tree-additive extractor on the simple acyclic case" + ); + assert_eq!(eboost_result.1, 1); +} + +#[test] +fn eboost_backend_prefers_shared_subexpression_over_duplicated_tree_choice() { + let _ = env_logger::builder().is_test(true).try_init(); + EBoostCseTx::sgl().reset_for_bench(); + + let shared_leaf = CLeaf::::new(0); + let shared_l1 = CInc::::new(&shared_leaf); + let shared = CInc::::new(&shared_l1); + let shared_root = CPair::::new(&shared, &shared); + shared_root.commit(); + + let left_leaf = CLeaf::::new(1); + let right_leaf = CLeaf::::new(2); + let left = CInc::::new(&left_leaf); + let right = CInc::::new(&right_leaf); + let duplicated_root = CPair::::new(&left, &right); + duplicated_root.commit(); + + let ruleset = EBoostCseTx::new_ruleset("union_common_subexpr_roots_for_eboost_test"); + EBoostCseTx::add_rule( + "union_common_subexpr_roots_for_eboost_test", + ruleset, + || { + let shared_leaf = CLeaf::query(); + let shared_l1 = CInc::query(&shared_leaf); + let shared = CInc::query(&shared_l1); + let shared_root = CPair::query(&shared, &shared); + + let left_leaf = CLeaf::query(); + let left = CInc::query(&left_leaf); + let right_leaf = CLeaf::query(); + let right = CInc::query(&right_leaf); + let duplicated_root = CPair::query(&left, &right); + #[eggplant::pat_vars_catch] + struct Pat { + shared_leaf: CLeaf, + shared_root: CPair, + left_leaf: CLeaf, + right_leaf: CLeaf, + duplicated_root: CPair, + } + }, + |ctx, pat| { + let shared_n = ctx.devalue(pat.shared_leaf.n); + let left_n = ctx.devalue(pat.left_leaf.n); + let right_n = ctx.devalue(pat.right_leaf.n); + if shared_n == 0 && left_n == 1 && right_n == 2 { + ctx.union(pat.shared_root, pat.duplicated_root); + } + }, + ); + EBoostCseTx::run_ruleset(ruleset, RunConfig::Once); + + let (legacy_rendered, legacy_cost) = EBoostCseTx::extract_node_to_string(&shared_root) + .expect("legacy extraction should succeed"); + let (eboost_rendered, eboost_cost) = EBoostCseTx::extract_node_to_string_with_backend( + &shared_root, + ExtractBackend::::eboost_heuristic( + EBoostExtractConfig::default(), + ), + ) + .expect("eboost backend should succeed on the common-subexpression case"); + + assert!( + legacy_rendered.contains("(CInc (CLeaf 1))") + && legacy_rendered.contains("(CInc (CLeaf 2))"), + "control check: legacy tree-additive extraction should over-count the shared subtree" + ); + assert!( + eboost_rendered.contains("(CInc (CInc (CLeaf 0)))"), + "eboost heuristic should prefer the shared-subexpression variant" + ); + assert!( + legacy_cost > eboost_cost, + "eboost heuristic should report a strictly smaller DAG-aware cost than legacy tree-additive extraction" + ); +} + +#[test] +fn eboost_backend_keeps_acyclic_witness_in_cyclic_root_class() { + let _ = env_logger::builder().is_test(true).try_init(); + EBoostCycleTx::sgl().reset_for_bench(); + + let leaf = CycleLeaf::::new(5); + let wrap = CycleWrap::::new(&leaf); + wrap.commit(); + + let ruleset = EBoostCycleTx::new_ruleset("union_cyclic_root_variants_for_eboost_test"); + EBoostCycleTx::add_rule( + "union_cyclic_root_variants_for_eboost_test", + ruleset, + || { + let leaf = CycleLeaf::query(); + let wrap = CycleWrap::query(&leaf); + #[eggplant::pat_vars_catch] + struct Pat { + leaf: CycleLeaf, + wrap: CycleWrap, + } + }, + |ctx, pat| { + ctx.union(pat.leaf, pat.wrap); + }, + ); + EBoostCycleTx::run_ruleset(ruleset, RunConfig::Once); + + let (legacy_rendered, _) = + EBoostCycleTx::extract_node_to_string(&leaf).expect("legacy extraction should succeed"); + let (eboost_rendered, eboost_cost) = EBoostCycleTx::extract_node_to_string_with_backend( + &leaf, + ExtractBackend::::eboost_heuristic( + EBoostExtractConfig::default(), + ), + ) + .expect("eboost backend should keep the acyclic witness even when the root class is cyclic"); + + assert!(legacy_rendered.contains("Leaf")); + assert!(eboost_rendered.contains("Leaf")); + assert_eq!(eboost_cost, 1); +} diff --git a/tests/eboost_layered_extract.rs b/tests/eboost_layered_extract.rs new file mode 100644 index 0000000..d623f00 --- /dev/null +++ b/tests/eboost_layered_extract.rs @@ -0,0 +1,184 @@ +#![cfg(feature = "rustsat-extract")] + +use eggplant::{prelude::*, tx_rx_vt_pr}; + +#[eggplant::dsl] +enum LayeredExpr { + Leaf { + n: i64, + }, + #[cost(0)] + CheapWrap { + inner: LayeredExpr, + }, + #[cost(5)] + ExpensiveWrap { + inner: LayeredExpr, + }, +} + +tx_rx_vt_pr!(LayeredDemoTx, LayeredDemoPatRec); + +#[eggplant::dsl] +enum LayeredCseExpr { + CLeaf { + n: i64, + }, + CInc { + inner: LayeredCseExpr, + }, + CPair { + lhs: LayeredCseExpr, + rhs: LayeredCseExpr, + }, +} + +tx_rx_vt_pr!(LayeredCseTx, LayeredCsePatRec); + +#[test] +fn layered_backend_matches_rustsat_on_simple_acyclic_wrapper_expression() { + let _ = env_logger::builder().is_test(true).try_init(); + LayeredDemoTx::sgl().reset_for_bench(); + + let leaf = Leaf::::new(7); + let cheap = CheapWrap::::new(&leaf); + cheap.commit(); + let expensive = ExpensiveWrap::::new(&leaf); + expensive.commit(); + + let ruleset = LayeredDemoTx::new_ruleset("union_wrapper_variants_for_layered_test"); + LayeredDemoTx::add_rule( + "union_wrapper_variants_for_layered_test", + ruleset, + || { + let leaf = Leaf::query(); + let cheap = CheapWrap::query(&leaf); + let expensive = ExpensiveWrap::query(&leaf); + #[eggplant::pat_vars_catch] + struct Pat { + cheap: CheapWrap, + expensive: ExpensiveWrap, + } + }, + |ctx, pat| { + ctx.union(pat.cheap, pat.expensive); + }, + ); + LayeredDemoTx::run_ruleset(ruleset, RunConfig::Once); + + let rustsat = LayeredDemoTx::extract_node_to_string_with_backend( + &cheap, + ExtractBackend::::rustsat( + RustsatExtractConfig::default(), + ), + ) + .expect("rustsat extraction should succeed"); + let layered = LayeredDemoTx::extract_node_to_string_with_backend( + &cheap, + ExtractBackend::::eboost_layered( + EBoostLayeredConfig::default(), + ), + ) + .expect("layered extraction should succeed"); + + assert_eq!(layered, rustsat); + assert!(layered.0.contains("CheapWrap")); +} + +#[test] +fn layered_backend_matches_rustsat_on_common_subexpression_case() { + let _ = env_logger::builder().is_test(true).try_init(); + LayeredCseTx::sgl().reset_for_bench(); + + let shared_leaf = CLeaf::::new(0); + let shared_l1 = CInc::::new(&shared_leaf); + let shared = CInc::::new(&shared_l1); + let shared_root = CPair::::new(&shared, &shared); + shared_root.commit(); + + let left_leaf = CLeaf::::new(1); + let right_leaf = CLeaf::::new(2); + let left = CInc::::new(&left_leaf); + let right = CInc::::new(&right_leaf); + let duplicated_root = CPair::::new(&left, &right); + duplicated_root.commit(); + + let ruleset = LayeredCseTx::new_ruleset("union_common_subexpr_roots_for_layered_test"); + LayeredCseTx::add_rule( + "union_common_subexpr_roots_for_layered_test", + ruleset, + || { + let shared_leaf = CLeaf::query(); + let shared_l1 = CInc::query(&shared_leaf); + let shared = CInc::query(&shared_l1); + let shared_root = CPair::query(&shared, &shared); + + let left_leaf = CLeaf::query(); + let left = CInc::query(&left_leaf); + let right_leaf = CLeaf::query(); + let right = CInc::query(&right_leaf); + let duplicated_root = CPair::query(&left, &right); + #[eggplant::pat_vars_catch] + struct Pat { + shared_leaf: CLeaf, + shared_root: CPair, + left_leaf: CLeaf, + right_leaf: CLeaf, + duplicated_root: CPair, + } + }, + |ctx, pat| { + let shared_n = ctx.devalue(pat.shared_leaf.n); + let left_n = ctx.devalue(pat.left_leaf.n); + let right_n = ctx.devalue(pat.right_leaf.n); + if shared_n == 0 && left_n == 1 && right_n == 2 { + ctx.union(pat.shared_root, pat.duplicated_root); + } + }, + ); + LayeredCseTx::run_ruleset(ruleset, RunConfig::Once); + + let rustsat = LayeredCseTx::extract_node_to_string_with_backend( + &shared_root, + ExtractBackend::::rustsat( + RustsatExtractConfig::default(), + ), + ) + .expect("rustsat extraction should succeed"); + let layered = LayeredCseTx::extract_node_to_string_with_backend( + &shared_root, + ExtractBackend::::eboost_layered( + EBoostLayeredConfig::default(), + ), + ) + .expect("layered extraction should succeed"); + + assert_eq!(layered, rustsat); + assert!(layered.0.contains("(CInc (CInc (CLeaf 0)))")); +} + +#[test] +fn layered_backend_rejects_invalid_pruning_bound_below_one() { + let _ = env_logger::builder().is_test(true).try_init(); + LayeredDemoTx::sgl().reset_for_bench(); + + let leaf = Leaf::::new(7); + let cheap = CheapWrap::::new(&leaf); + cheap.commit(); + + let err = LayeredDemoTx::extract_node_to_string_with_backend( + &cheap, + ExtractBackend::::eboost_layered( + EBoostLayeredConfig { + bound: 0.95, + exact: RustsatExtractConfig::default(), + }, + ), + ) + .expect_err("layered backend should reject pruning bounds below one"); + + assert!( + err.to_string().contains("bound"), + "error should mention the invalid pruning bound: {err}" + ); +} diff --git a/tests/extract_typst_svg.rs b/tests/extract_typst_svg.rs new file mode 100644 index 0000000..ccd137f --- /dev/null +++ b/tests/extract_typst_svg.rs @@ -0,0 +1,96 @@ +use eggplant::{prelude::*, tx_rx_vt_pr}; +use std::fs; +use std::path::PathBuf; +use std::time::{SystemTime, UNIX_EPOCH}; + +#[eggplant::dsl] +enum RenderExpr { + #[typst("{name}")] + #[precedence(100)] + Var { name: String }, + #[typst("{n}")] + #[precedence(100)] + Const { n: i64 }, + #[typst("{lhs} + {rhs}")] + #[precedence(10)] + Add { lhs: RenderExpr, rhs: RenderExpr }, + #[typst("{lhs} * {rhs}")] + #[precedence(20)] + Mul { lhs: RenderExpr, rhs: RenderExpr }, +} + +tx_rx_vt_pr!(RenderTx, RenderPatRec); + +fn unique_svg_path() -> PathBuf { + let nanos = SystemTime::now() + .duration_since(UNIX_EPOCH) + .unwrap() + .as_nanos(); + std::env::temp_dir().join(format!("eggplant_extract_render_{nanos}.svg")) +} + +#[test] +fn extract_node_to_typst_with_backend_renders_using_typst_templates_and_precedence() { + let _ = env_logger::builder().is_test(true).try_init(); + RenderTx::sgl().reset_for_bench(); + + let x = Var::::new("x".to_owned()); + x.commit(); + let y = Var::::new("y".to_owned()); + y.commit(); + let z = Var::::new("z".to_owned()); + z.commit(); + + let add_xy = Add::::new(&x, &y); + add_xy.commit(); + let mul = Mul::::new(&add_xy, &z); + mul.commit(); + + let (typst, _cost) = RenderTx::extract_node_to_typst_with_backend( + &mul, + ExtractBackend::::cost_model( + eggplant::egglog::extract::TreeAdditiveCostModel::default(), + ), + ) + .expect("typst rendering should succeed"); + + assert_eq!(typst, "(x + y) * z"); +} + +#[test] +fn extract_node_to_svg_with_backend_writes_svg_file() { + let _ = env_logger::builder().is_test(true).try_init(); + RenderTx::sgl().reset_for_bench(); + + if std::process::Command::new("typst") + .arg("--version") + .status() + .is_err() + { + eprintln!("skipping svg render test because `typst` CLI is unavailable"); + return; + } + + let one = Const::::new(1); + one.commit(); + let two = Const::::new(2); + two.commit(); + let add = Add::::new(&one, &two); + add.commit(); + + let output_path = unique_svg_path(); + let cost = RenderTx::extract_node_to_svg_with_backend( + &add, + ExtractBackend::::cost_model( + eggplant::egglog::extract::TreeAdditiveCostModel::default(), + ), + &output_path, + ) + .expect("svg rendering should succeed"); + + let svg = fs::read_to_string(&output_path).expect("svg file should be readable"); + assert!(svg.contains(" 0); + + let _ = fs::remove_file(output_path); +} diff --git a/tests/proof_singleton_macro.rs b/tests/proof_singleton_macro.rs new file mode 100644 index 0000000..e0bdd0e --- /dev/null +++ b/tests/proof_singleton_macro.rs @@ -0,0 +1,11 @@ +use eggplant::prelude::*; + +tx_rx_vt_pr_pf!(MacroTxProof, MacroPatRec); + +#[test] +fn tx_rx_vt_pr_pf_macro_builds_a_proof_tx_singleton() { + let _ = MacroTxProof::sgl(); + let _ = MacroPatRec::sgl(); + let egraph = MacroTxProof::egraph(); + assert!(egraph.lock().unwrap().are_proofs_enabled()); +} diff --git a/tests/schedule_builder.rs b/tests/schedule_builder.rs new file mode 100644 index 0000000..d29cbaf --- /dev/null +++ b/tests/schedule_builder.rs @@ -0,0 +1,71 @@ +#![allow(non_camel_case_types)] + +use eggplant::{prelude::*, tx_rx_vt_pr}; + +#[eggplant::func(output = i64, no_merge)] +struct sched_fib { + x: i64, +} + +#[eggplant::pat_vars] +struct FibStep { + x: i64, + x1: i64, + x2: i64, + f0: i64, + f1: i64, +} + +tx_rx_vt_pr!(ScheduleBuilderTx, ScheduleBuilderPatRec); + +#[test] +fn schedule_builder_runs_nested_repeat_schedule() { + let seed = ScheduleBuilderTx::new_ruleset("schedule_builder_seed"); + ScheduleBuilderTx::add_rule( + "schedule_builder_seed", + seed, + || { + #[eggplant::pat_vars_catch] + struct Unit {} + }, + |ctx, _pat| { + ctx.set_sched_fib(0, 0); + ctx.set_sched_fib(1, 1); + }, + ); + + let step = ScheduleBuilderTx::new_ruleset("schedule_builder_step"); + ScheduleBuilderTx::add_rule( + "schedule_builder_step", + step, + || { + let (x, x1, x2) = ( + sched_fib::x(), + sched_fib::x().named("x1"), + sched_fib::x().named("x2"), + ); + let x1_constraint = x1.handle().eq(&(x.handle() + (&1_i64).as_handle())); + let x2_constraint = x2.handle().eq(&(x.handle() + (&2_i64).as_handle())); + let f0 = sched_fib::query(&x); + let f1 = sched_fib::query(&x1); + FibStep::new(x, x1, x2, f0, f1) + .assert(x1_constraint) + .assert(x2_constraint) + }, + |ctx, pat| { + let x2 = ctx.devalue(pat.x2); + let f0 = ctx.devalue(pat.f0); + let f1 = ctx.devalue(pat.f1); + ctx.set_sched_fib(x2, f0 + f1); + }, + ); + + let schedule = RunSchedule::builder() + .run(seed) + .repeat(7, |schedule| schedule.run(step)) + .build(); + + ScheduleBuilderTx::run_schedule(schedule); + + assert_eq!(sched_fib::::get(&7), 13); +} diff --git a/tests/session_tx_constant_prop.rs b/tests/session_tx_constant_prop.rs index 19754ff..bb8225e 100644 --- a/tests/session_tx_constant_prop.rs +++ b/tests/session_tx_constant_prop.rs @@ -45,35 +45,19 @@ fn register_constant_prop_rules() -> RuleSetId { }) } -fn current_snapshot() -> PersistedSnapshot { +fn current_session_has_const(needle: i64) -> bool { let egraph = MyTx::egraph(); let egraph = egraph.lock().unwrap(); - build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()) -} - -fn snapshot_has_const(snapshot: &PersistedSnapshot, needle: i64) -> bool { - let Some(const_decl) = snapshot - .schema - .constructor_decls - .iter() - .find(|decl| decl.name == "Const") - else { - return false; - }; - snapshot.state.function_rows.iter().any(|row| { - row.op_id == const_decl.op_id - && matches!( - row.inputs.first(), - Some(PersistedSnapshotValue::Lit { value, .. }) if value.value == needle.to_string() - ) + egraph.function_rows("Const").into_iter().any(|row| { + !row.subsumed + && row + .vals + .first() + .is_some_and(|value| egraph.value_to_base::(*value) == needle) }) } -fn current_session_has_const(needle: i64) -> bool { - snapshot_has_const(¤t_snapshot(), needle) -} - fn canonical_eq(lhs: &Expr, rhs_const: i64) -> bool { let rhs: Expr = Const::new(rhs_const); rhs.commit(); @@ -183,10 +167,25 @@ fn tx_sessions_support_async_task_local_routing() { }); assert_eq!(right_join.await.unwrap(), 26); - assert!(left.run_async(async { current_session_has_const(10) }).await); - assert!(!left.run_async(async { current_session_has_const(26) }).await); - assert!(right.run_async(async { current_session_has_const(26) }).await); - assert!(!right.run_async(async { current_session_has_const(10) }).await); + assert!( + left.run_async(async { current_session_has_const(10) }) + .await + ); + assert!( + !left + .run_async(async { current_session_has_const(26) }) + .await + ); + assert!( + right + .run_async(async { current_session_has_const(26) }) + .await + ); + assert!( + !right + .run_async(async { current_session_has_const(10) }) + .await + ); }); } diff --git a/tests/tx_sessions.rs b/tests/tx_sessions.rs index 11f254a..aefdf78 100644 --- a/tests/tx_sessions.rs +++ b/tests/tx_sessions.rs @@ -40,7 +40,8 @@ macro_rules! prop { fn register_rules() -> RuleSetId { static NEXT_RULESET_ID: AtomicUsize = AtomicUsize::new(0); let id = NEXT_RULESET_ID.fetch_add(1, Ordering::Relaxed); - let name: &'static str = Box::leak(format!("session_aware_constant_prop_{id}").into_boxed_str()); + let name: &'static str = + Box::leak(format!("session_aware_constant_prop_{id}").into_boxed_str()); let ruleset = SessionTx::new_ruleset(name); prop!("AddPat", Add, +, AddPat, ruleset); prop!("MulPat", Mul, *, MulPat, ruleset); @@ -56,23 +57,13 @@ fn canonical_eq(lhs: &SessionExpr, rhs_const: i64) -> bool { fn current_has_const(needle: i64) -> bool { let egraph = SessionTx::egraph(); let egraph = egraph.lock().unwrap(); - let snapshot = build_persisted_snapshot_v1(&egraph, egglog::SerializeConfig::default()); - - let Some(const_decl) = snapshot - .schema - .constructor_decls - .iter() - .find(|decl| decl.name == "Const") - else { - return false; - }; - snapshot.state.function_rows.iter().any(|row| { - row.op_id == const_decl.op_id - && matches!( - row.inputs.first(), - Some(PersistedSnapshotValue::Lit { value, .. }) if value.value == needle.to_string() - ) + egraph.function_rows("Const").into_iter().any(|row| { + !row.subsumed + && row + .vals + .first() + .is_some_and(|value| egraph.value_to_base::(*value) == needle) }) } @@ -151,7 +142,10 @@ fn fold_active_mul_add_expr_alt(lhs: i64, rhs: i64, addend: i64) -> i64 { let expected = lhs * rhs + addend; let rhs: SessionExpr = Const::new(expected); rhs.commit(); - assert_eq!(AltSessionTx::canonical_raw(&expr), AltSessionTx::canonical_raw(&rhs)); + assert_eq!( + AltSessionTx::canonical_raw(&expr), + AltSessionTx::canonical_raw(&rhs) + ); expected } diff --git a/tests/typed_extract_cost_model.rs b/tests/typed_extract_cost_model.rs index 5d37030..a8667c8 100644 --- a/tests/typed_extract_cost_model.rs +++ b/tests/typed_extract_cost_model.rs @@ -176,6 +176,7 @@ fn typed_extract_backend_cost_model_matches_existing_cost_model_api() { assert_eq!(via_backend, existing); } +#[cfg(feature = "rustsat-extract")] #[test] fn typed_extract_backend_rustsat_uses_variant_costs_over_custom_cost_model_bias() { let _ = env_logger::builder().is_test(true).try_init(); diff --git a/tests/typed_lookup_fastpath.rs b/tests/typed_lookup_fastpath.rs index 04792d0..038f0f2 100644 --- a/tests/typed_lookup_fastpath.rs +++ b/tests/typed_lookup_fastpath.rs @@ -31,10 +31,9 @@ fn fast_add_pat() -> FastAddPat { #[test] fn cached_lookup_matches_named_lookup() { - static FAST_ADD_ID: OnceLock = OnceLock::new(); + static FAST_ADD_ID: OnceLock = OnceLock::new(); - let root = - FastRootNode::::new(&FastAdd::new(&FastConst::new(2), &FastConst::new(3))); + let root = FastRootNode::::new(&FastAdd::new(&FastConst::new(2), &FastConst::new(3))); root.commit(); let ruleset = FastTx::new_ruleset("cached_lookup_matches_named_lookup"); From 34a6c609901352a4c1b49bd85d2113043919da34 Mon Sep 17 00:00:00 2001 From: MilkBlock <2386925778@qq.com> Date: Wed, 6 May 2026 16:13:58 +0800 Subject: [PATCH 7/8] refactor(viewer): align serialized graph and fixture tests --- dynamic_action_trace_demo.json | 34 ++++ eggplant-viewer/src/start.rs | 155 ++++++------------ sample_trace.json | 6 +- tests/persisted_snapshot_corpus_validation.rs | 4 +- tests/persisted_snapshot_fixture_stability.rs | 4 +- tests/rustsat_common_subexpr.rs | 2 + tests/rustsat_optimize_expression.rs | 2 + 7 files changed, 99 insertions(+), 108 deletions(-) create mode 100644 dynamic_action_trace_demo.json diff --git a/dynamic_action_trace_demo.json b/dynamic_action_trace_demo.json new file mode 100644 index 0000000..702d7bc --- /dev/null +++ b/dynamic_action_trace_demo.json @@ -0,0 +1,34 @@ +{ + "version": 1, + "events": [ + { + "kind": "insert", + "id": "evt_0", + "effect_id": "effect@2281:2306", + "table": "TraceConst", + "key_debug": [ + "Value(2)" + ], + "rendered_label": "sample:const(2)" + }, + { + "kind": "insert", + "id": "evt_1", + "effect_id": "effect@2334:2366", + "table": "TraceMul", + "key_debug": [ + "Value(1)", + "Value(4)" + ], + "rendered_label": "sample:mul(r, 2)" + }, + { + "kind": "union", + "id": "evt_2", + "effect_id": "effect@2384:2408", + "lhs_debug": "Value(2)", + "rhs_debug": "Value(5)", + "rendered_label": "sample:union(expr, mul(r, 2))" + } + ] +} \ No newline at end of file diff --git a/eggplant-viewer/src/start.rs b/eggplant-viewer/src/start.rs index 54ae774..162a397 100644 --- a/eggplant-viewer/src/start.rs +++ b/eggplant-viewer/src/start.rs @@ -1,11 +1,11 @@ use eframe::CreationContext; -use egglog::{EGraph, RawEGraphNode, SerializeConfig, Value}; +use egglog::{EGraph, SerializeConfig, Value, sort::Sort}; +use egglog_numeric_id::NumericId; use eggplant_egui_graphs::{ ENode, EventHandler, FuncOffset, Graph, InnerPos, MaybeInner, ViewEdge, ViewNode, }; use indexmap::IndexMap; use petgraph::prelude::StableGraph; -use std::collections::HashMap; #[cfg(feature = "events")] use crate::event_filters::EventFilters; @@ -19,6 +19,12 @@ struct ValueWithCano { sort: SortName, offset: usize, } + +struct SerializedRow { + inputs_complex: Vec, + basics: Vec, + output: ValueWithCano, +} impl EGraphApp { pub fn new( cc: &CreationContext<'_>, @@ -27,107 +33,59 @@ impl EGraphApp { event_handler: Box, ) -> Self { let mut g = Graph::new(StableGraph::default()); - let tables = { - let tables = egraph.serialize_raw(SerializeConfig::default()); - let tables = tables - .iter() - .map(|(k, v)| { - ( - k.clone(), - v.iter() - .enumerate() - .map(|(offset, node)| { - let inputs_complex = node - .inputs_complex - .iter() - .enumerate() - .filter_map(|(i, value)| { - let sort = &egraph - .get_function(&k) - .unwrap_or_else(|| panic!("can't find func {}", k)) - .schema() - .input - .get(i) - .unwrap(); - if egraph.is_base_sort(sort) { - None - } else { - let cano_value = - egraph.get_canonical_value(*value, sort); - println!( - "canno value of {}{} is {}", - k, - value.rep(), - cano_value.rep() - ); - Some(ValueWithCano { - value: *value, - cano_value, - sort: sort.name().to_string(), - offset, - }) - } - }) - .collect(); - let basics = node - .inputs_complex - .iter() - .enumerate() - .filter_map(|(i, value)| { - let sort = &egraph - .get_function(&k) - .unwrap_or_else(|| panic!("can't find func {}", k)) - .schema() - .input - .get(i) - .unwrap(); - if egraph.is_base_sort(sort) { - Some(value.rep()) - } else { - None - } - }) - .collect::>(); - RawEGraphNode { - inputs_complex, - basics, - output: ValueWithCano { - value: node.output, - cano_value: egraph.get_canonical_value( - node.output, - &egraph - .get_function(&k) - .unwrap_or_else(|| panic!("can't find func {}", k)) - .schema() - .output, - ), - sort: { k.to_string() }, - offset, - }, - term: node.term, - subsumed: node.subsumed, - class_name: node.class_name.clone(), - node_name: node.node_name.clone(), - } - }) - .collect::>>(), - ) - }) - .collect::>>(); - tables - }; - let class2nodes: IndexMap> = + let serialized = egraph.serialize(SerializeConfig { + include_temporary_functions: true, + ..SerializeConfig::default() + }); + let serialized_graph = serialized.egraph; + let mut tables: IndexMap> = IndexMap::new(); + for (node_id, node) in &serialized_graph.nodes { + let func = node.op.clone(); + let function = egraph + .get_function(&func) + .unwrap_or_else(|| panic!("can't find func {}", func)); + let row_offset = tables.get(&func).map_or(0, Vec::len); + let output_sort = function.schema().output.clone(); + let output_value = egraph.class_id_to_value(&node.eclass); + let mut inputs_complex = Vec::new(); + let mut basics = Vec::new(); + for (i, child) in node.children.iter().enumerate() { + let sort = function.schema().input.get(i).unwrap(); + let child_value = egraph.class_id_to_value(serialized_graph.nid_to_cid(child)); + if sort.value_type().is_some() { + basics.push(child_value.rep()); + } else { + inputs_complex.push(ValueWithCano { + value: child_value.clone(), + cano_value: child_value, + sort: sort.name().to_string(), + offset: row_offset, + }); + } + } + let _ = node_id; + tables.entry(func).or_default().push(SerializedRow { + inputs_complex, + basics, + output: ValueWithCano { + value: output_value.clone(), + cano_value: output_value, + sort: output_sort.name().to_string(), + offset: row_offset, + }, + }); + } + let class2nodes: IndexMap> = tables .iter() .fold(IndexMap::default(), |mut acc, (func, rows)| { rows.iter().enumerate().for_each(|(tbl_offset, row)| { - acc.entry(row.output.cano_value) + acc.entry(row.output.cano_value.rep()) .or_default() .push((func.clone(), tbl_offset)) }); acc }); - println!("{:?}", class2nodes); // add nodes let mut cano_value2node_idx = IndexMap::new(); @@ -145,7 +103,7 @@ impl EGraphApp { .get(*offset) .unwrap_or_else(|| panic!("row {} in func {} not found", offset, func)); cano_value = Some(row.output.cano_value); - let enode = trans_raw_egraph_node(func.to_string(), *offset, row); + let enode = trans_serialized_row_node(func.to_string(), *offset, row); sort_offset2cano_value_and_maybe_inner.insert( FuncOffset::new(row.output.sort.clone(), *offset), ( @@ -295,11 +253,7 @@ impl EGraphApp { } } -fn trans_raw_egraph_node( - func: String, - offset: usize, - row: &egglog::RawEGraphNode, ValueWithCano>, -) -> ENode { +fn trans_serialized_row_node(func: String, offset: usize, row: &SerializedRow) -> ENode { ENode { func_offset: FuncOffset { func, offset }, cano_value: row.output.cano_value.rep(), @@ -309,4 +263,3 @@ fn trans_raw_egraph_node( dsl_metadata: None, } } -use egglog::NumericId; diff --git a/sample_trace.json b/sample_trace.json index a2460d9..90296a1 100644 --- a/sample_trace.json +++ b/sample_trace.json @@ -4,7 +4,7 @@ { "Insert": { "event_id": "evt_0", - "effect_id": "effect@13759:13784", + "effect_id": "effect@14286:14311", "table": "TraceConst", "key_debug": [ "Value(1)" @@ -14,7 +14,7 @@ { "Insert": { "event_id": "evt_1", - "effect_id": "effect@13759:13784", + "effect_id": "effect@14286:14311", "table": "TraceAdd", "key_debug": [ "Value(2)", @@ -25,7 +25,7 @@ { "Union": { "event_id": "evt_2", - "effect_id": "effect@1311:1331", + "effect_id": null, "lhs_debug": "Value(2)", "rhs_debug": "Value(5)" } diff --git a/tests/persisted_snapshot_corpus_validation.rs b/tests/persisted_snapshot_corpus_validation.rs index 52bd8a6..0ee93e1 100644 --- a/tests/persisted_snapshot_corpus_validation.rs +++ b/tests/persisted_snapshot_corpus_validation.rs @@ -142,7 +142,7 @@ fn persisted_snapshot_corpus_hooked_user_base_round_trips() { "#, ) .unwrap(); - eggplant::egglog::prelude::run_ephemeral_rust_rule( + run_ephemeral_rust_rule( &mut seeded, "seed_corpus_hooked_base", &[], @@ -204,7 +204,7 @@ fn persisted_snapshot_corpus_unhooked_user_base_reports_gap_and_fails_restore() "#, ) .unwrap(); - eggplant::egglog::prelude::run_ephemeral_rust_rule( + run_ephemeral_rust_rule( &mut seeded, "seed_corpus_unhooked_base", &[], diff --git a/tests/persisted_snapshot_fixture_stability.rs b/tests/persisted_snapshot_fixture_stability.rs index 09f8f74..9d52e84 100644 --- a/tests/persisted_snapshot_fixture_stability.rs +++ b/tests/persisted_snapshot_fixture_stability.rs @@ -49,7 +49,7 @@ impl eggplant::wrap::PersistedSnapshotUserBaseSortHook for HookedFixtureBaseRest fn restore_machine_value( &self, - ctx: &mut eggplant::egglog::prelude::RustRuleContext<'_, '_, '_>, + ctx: &mut eggplant::egglog::prelude::RustRuleContext<'_, '_>, machine_value: &serde_json::Value, ) -> Result { let n = machine_value @@ -203,7 +203,7 @@ fn build_hooked_user_base_snapshot() -> PersistedSnapshot { "#, ) .unwrap(); - eggplant::egglog::prelude::run_ephemeral_rust_rule( + run_ephemeral_rust_rule( &mut egraph, "seed_hooked_fixture_snapshot", &[], diff --git a/tests/rustsat_common_subexpr.rs b/tests/rustsat_common_subexpr.rs index 9ea0ecc..9aef14d 100644 --- a/tests/rustsat_common_subexpr.rs +++ b/tests/rustsat_common_subexpr.rs @@ -1,3 +1,5 @@ +#![cfg(feature = "rustsat-extract")] + use eggplant::{prelude::*, tx_rx_vt_pr}; #[eggplant::dsl] diff --git a/tests/rustsat_optimize_expression.rs b/tests/rustsat_optimize_expression.rs index 2490223..6b449bf 100644 --- a/tests/rustsat_optimize_expression.rs +++ b/tests/rustsat_optimize_expression.rs @@ -1,3 +1,5 @@ +#![cfg(feature = "rustsat-extract")] + use eggplant::{prelude::*, tx_rx_vt_pr}; #[eggplant::dsl] From d331f1aea3c93ccf14eabe42edea59182e71c9f0 Mon Sep 17 00:00:00 2001 From: MilkBlock <2386925778@qq.com> Date: Wed, 6 May 2026 16:18:51 +0800 Subject: [PATCH 8/8] feat(bench): add benchmark report and microbench suites --- benches/common.rs | 29 +- benches/eggplant_bench.rs | 20 +- .../eggplant_rewrite/math_microbenchmark.rs | 1663 ++++++++++------ .../math_microbenchmark_no_calculus.rs | 1672 +++++++++++++++++ .../eggplant_rewrite/merge_during_rebuild.rs | 4 +- .../eggplant_rewrite/repro_665_set_union.rs | 42 +- .../runners/eggplant_rewrite/vec_builtins.rs | 163 +- .../runners/eggplant_rewrite/web_demo_set.rs | 394 ++-- .../eggplant_rewrite/web_demo_unify.rs | 106 +- benches/runners/generated/eggcc_extraction.rs | 364 ++-- .../runners/generated/extract_vec_bench.rs | 164 +- benches/runners/generated/taylor51.rs | 104 +- examples/_math_microbench_compare.rs | 4 +- examples/_math_microbench_compare_5.rs | 156 ++ examples/math_microbenchmark_extract_bench.rs | 132 ++ ...icrobenchmark_no_calculus_extract_bench.rs | 133 ++ ...robenchmark_no_calculus_timeline_export.rs | 114 ++ examples/math_microbenchmark_support.rs | 36 +- examples/nncase_clamp_extract_bench.rs | 114 ++ examples/nncase_clamp_timeline_export.rs | 108 ++ examples/nncase_transpose_extract_bench.rs | 113 ++ examples/nncase_transpose_timeline_export.rs | 113 ++ examples/nncase_vectorize_extract_bench.rs | 115 ++ examples/nncase_vectorize_timeline_export.rs | 108 ++ src/benchmarks/mod.rs | 3 + src/benchmarks/nncase_clamp_microbenchmark.rs | 827 ++++++++ .../nncase_transpose_microbenchmark.rs | 889 +++++++++ .../nncase_vectorize_microbenchmark.rs | 876 +++++++++ src/helpers/bench_cli.rs | 171 ++ src/helpers/mod.rs | 4 + src/helpers/progress.rs | 161 ++ src/helpers/report.rs | 867 +++++++++ src/helpers/runtime.rs | 114 ++ tests/math_microbench_compare.rs | 4 +- tests/math_microbench_div_distrib.rs | 44 + tests/math_microbench_extract_cli.rs | 53 + tests/math_microbench_extract_report.rs | 41 + tests/math_microbench_no_calculus.rs | 115 ++ tests/math_microbench_quarto_report.rs | 30 + tests/math_microbench_timeline_cli.rs | 56 + tests/nncase_clamp_cli.rs | 82 + tests/nncase_clamp_microbench.rs | 100 + tests/nncase_transpose_cli.rs | 91 + tests/nncase_transpose_microbench.rs | 115 ++ tests/nncase_vectorize_cli.rs | 84 + tests/nncase_vectorize_microbench.rs | 103 + tests/timeline_markdown_report.rs | 170 ++ 47 files changed, 9648 insertions(+), 1323 deletions(-) create mode 100644 benches/runners/eggplant_rewrite/math_microbenchmark_no_calculus.rs create mode 100644 examples/_math_microbench_compare_5.rs create mode 100644 examples/math_microbenchmark_extract_bench.rs create mode 100644 examples/math_microbenchmark_no_calculus_extract_bench.rs create mode 100644 examples/math_microbenchmark_no_calculus_timeline_export.rs create mode 100644 examples/nncase_clamp_extract_bench.rs create mode 100644 examples/nncase_clamp_timeline_export.rs create mode 100644 examples/nncase_transpose_extract_bench.rs create mode 100644 examples/nncase_transpose_timeline_export.rs create mode 100644 examples/nncase_vectorize_extract_bench.rs create mode 100644 examples/nncase_vectorize_timeline_export.rs create mode 100644 src/benchmarks/mod.rs create mode 100644 src/benchmarks/nncase_clamp_microbenchmark.rs create mode 100644 src/benchmarks/nncase_transpose_microbenchmark.rs create mode 100644 src/benchmarks/nncase_vectorize_microbenchmark.rs create mode 100644 src/helpers/bench_cli.rs create mode 100644 src/helpers/mod.rs create mode 100644 src/helpers/progress.rs create mode 100644 src/helpers/report.rs create mode 100644 src/helpers/runtime.rs create mode 100644 tests/math_microbench_div_distrib.rs create mode 100644 tests/math_microbench_extract_cli.rs create mode 100644 tests/math_microbench_extract_report.rs create mode 100644 tests/math_microbench_no_calculus.rs create mode 100644 tests/math_microbench_quarto_report.rs create mode 100644 tests/math_microbench_timeline_cli.rs create mode 100644 tests/nncase_clamp_cli.rs create mode 100644 tests/nncase_clamp_microbench.rs create mode 100644 tests/nncase_transpose_cli.rs create mode 100644 tests/nncase_transpose_microbench.rs create mode 100644 tests/nncase_vectorize_cli.rs create mode 100644 tests/nncase_vectorize_microbench.rs create mode 100644 tests/timeline_markdown_report.rs diff --git a/benches/common.rs b/benches/common.rs index cb11b03..b7f419c 100644 --- a/benches/common.rs +++ b/benches/common.rs @@ -2,9 +2,9 @@ use egglog::EGraph; use egglog::SerializeConfig; use egglog::Value; use egglog::prelude::*; +use eggplant::prelude::EgglogCompatExt; use std::path::Path; use std::path::PathBuf; -use std::sync::Arc; use std::sync::Once; #[global_allocator] @@ -322,21 +322,10 @@ pub fn bench_union_chain(n_edges: usize, proofs: bool, typed_union: bool, do_pro .output .clone(); - let edge_view_proof: Option> = if proofs && typed_union { - Some(Arc::::from( - egraph - .proof_view_proof_name("Edge") - .expect("Edge should have a view-proof function in proofs mode") - .to_owned(), - )) - } else { - None - }; - // One rust rule: for each (Edge a b), union Node(a) ~ Node(b). // - // Use an `=` fact to bind the (instrumented) output value so we can also look up - // the row's view-proof value in proofs mode. + // Use an `=` fact to bind the instrumented output value. In proofs mode egglog + // now carries the matching premise proof into RustRuleContext automatically. rust_rule( &mut egraph, "union_chain", @@ -344,19 +333,11 @@ pub fn bench_union_chain(n_edges: usize, proofs: bool, typed_union: bool, do_pro vars![a: i64, b: i64, u: { edge_output_sort.clone() }], facts![(= u (Edge a b))], move |ctx: &mut RustRuleContext, values: &[Value]| { - let [a, b, u] = values else { unreachable!() }; + let [a, b, _u] = values else { unreachable!() }; let node_a = ctx.lookup("Node", &[*a]).unwrap(); let node_b = ctx.lookup("Node", &[*b]).unwrap(); if typed_union { - let premise_proofs: Option<[Value; 1]> = edge_view_proof.as_ref().map(|vp| { - let prf = ctx.lookup(vp.as_ref(), &[*a, *b, *u]).unwrap(); - [prf] - }); - if let Some(premises) = premise_proofs.as_ref() { - ctx.union_typed("Expr", node_a, node_b, premises.as_slice()); - } else { - ctx.union_typed("Expr", node_a, node_b, &[]); - } + ctx.union_typed("Expr", node_a, node_b); } else { ctx.union(node_a, node_b); } diff --git a/benches/eggplant_bench.rs b/benches/eggplant_bench.rs index 738261d..ef8f551 100644 --- a/benches/eggplant_bench.rs +++ b/benches/eggplant_bench.rs @@ -3,20 +3,20 @@ use eggplant::tx_rx_vt_pr; #[eggplant::dsl] pub enum Expr { - #[eggplant::typst("{num}")] - #[eggplant::precedence(100)] + #[typst("{num}")] + #[precedence(100)] Const { num: i64 }, - #[eggplant::typst("{l} * {r}")] - #[eggplant::precedence(60)] + #[typst("{l} * {r}")] + #[precedence(60)] Mul { l: Expr, r: Expr }, - #[eggplant::typst("{l} - {r}")] - #[eggplant::precedence(50)] + #[typst("{l} - {r}")] + #[precedence(50)] Sub { l: Expr, r: Expr }, - #[eggplant::typst("{l} + {r}")] - #[eggplant::precedence(50)] + #[typst("{l} + {r}")] + #[precedence(50)] Add { l: Expr, r: Expr }, - #[eggplant::typst("frac({l}, {r})")] - #[eggplant::precedence(60)] + #[typst("frac({l}, {r})")] + #[precedence(60)] Div { l: Expr, r: Expr }, } diff --git a/benches/runners/eggplant_rewrite/math_microbenchmark.rs b/benches/runners/eggplant_rewrite/math_microbenchmark.rs index 9e725c5..2b92697 100644 --- a/benches/runners/eggplant_rewrite/math_microbenchmark.rs +++ b/benches/runners/eggplant_rewrite/math_microbenchmark.rs @@ -1,54 +1,77 @@ use egglog_reports::RunReport; use eggplant::prelude::*; use eggplant::tx_rx_vt_pr; -use eggplant::wrap::{PRRuleCtx, PatVars}; +use eggplant::wrap::NonPatRecSgl; +use libc::{RUSAGE_SELF, getrusage, rusage}; use std::collections::BTreeMap; use std::sync::{Arc, Mutex}; use std::time::{Duration, Instant}; +#[cfg(feature = "rustsat-extract")] +use eggplant::egglog::extract::TreeAdditiveCostModel; +#[cfg(feature = "rustsat-extract")] +use eggplant::wrap::EgglogTy; +#[cfg(feature = "rustsat-extract")] +use std::fs; +#[cfg(feature = "rustsat-extract")] +use std::path::PathBuf; + #[eggplant::dsl] enum Math { - #[eggplant::typst("{f}'({x})")] - #[eggplant::precedence(90)] + #[typst("{f}'({x})")] + #[precedence(90)] + #[cost(32)] MDiff { x: Math, f: Math }, - #[eggplant::typst("integral {f} quad d {x}")] - #[eggplant::precedence(90)] + #[typst("integral {f} quad d {x}")] + #[precedence(90)] + #[cost(40)] MIntegral { f: Math, x: Math }, - #[eggplant::typst("{a} + {b}")] - #[eggplant::precedence(50)] + #[typst("{a} + {b}")] + #[precedence(50)] + #[cost(1)] MAdd { a: Math, b: Math }, - #[eggplant::typst("{a} - {b}")] - #[eggplant::precedence(50)] + #[typst("{a} - {b}")] + #[precedence(50)] + #[cost(1)] MSub { a: Math, b: Math }, - #[eggplant::typst("{a} * {b}")] - #[eggplant::precedence(60)] + #[typst("{a} * {b}")] + #[precedence(60)] + #[cost(3)] MMul { a: Math, b: Math }, - #[eggplant::typst("frac({a}, {b}) ")] - #[eggplant::precedence(60)] + #[typst("frac({a}, {b}) ")] + #[precedence(60)] + #[cost(10)] MDiv { a: Math, b: Math }, - #[eggplant::typst("{a}^{b}")] - #[eggplant::precedence(80)] + #[typst("{a}^{b}")] + #[precedence(80)] + #[cost(25)] MPow { a: Math, b: Math }, - #[eggplant::typst("ln {a}")] - #[eggplant::precedence(90)] + #[typst("ln {a}")] + #[precedence(90)] + #[cost(18)] MLn { a: Math }, - #[eggplant::typst("sqrt({a})")] - #[eggplant::precedence(90)] + #[typst("sqrt({a})")] + #[precedence(90)] + #[cost(16)] MSqrt { a: Math }, - #[eggplant::typst("sin({a})")] - #[eggplant::precedence(90)] + #[typst("sin({a})")] + #[precedence(90)] + #[cost(18)] MSin { a: Math }, - #[eggplant::typst("cos({a})")] - #[eggplant::precedence(90)] + #[typst("cos({a})")] + #[precedence(90)] + #[cost(18)] MCos { a: Math }, - #[eggplant::typst("{n}")] - #[eggplant::precedence(100)] + #[typst("{n}")] + #[precedence(100)] + #[cost(0)] MConst { n: i64 }, - #[eggplant::typst("{name}")] - #[eggplant::precedence(100)] + #[typst("{name}")] + #[precedence(100)] + #[cost(0)] MVar { name: String }, } @@ -66,6 +89,43 @@ pub struct MathMicrobenchmarkStats { pub elapsed: Duration, pub total_num_tuples: usize, pub table_sizes: Vec<(&'static str, usize)>, + pub max_rewrite_mem_gib: u64, + pub rewrite_peak_memory_bytes: u64, + pub requested_rewrite_iters: usize, + pub executed_rewrite_iters: usize, + pub rewrite_stopped_early_due_to_memory_cap: bool, +} + +pub struct MathExtractComparisonRow { + pub method: &'static str, + pub requested_rewrite_iters: usize, + pub executed_rewrite_iters: usize, + pub max_rewrite_mem_gib: u64, + pub run_ruleset_note: String, + pub rewrite_peak_memory_bytes: u64, + pub extract_peak_memory_bytes: u64, + pub elapsed: Duration, + pub rendered: String, + pub svg_path: String, +} + +const DEFAULT_RUN_RULESET_MEMORY_CAP_GIB: u64 = 20; + +fn current_peak_memory_bytes() -> u64 { + let mut usage = std::mem::MaybeUninit::::uninit(); + let rc = unsafe { getrusage(RUSAGE_SELF, usage.as_mut_ptr()) }; + if rc != 0 { + return 0; + } + let usage = unsafe { usage.assume_init() }; + #[cfg(target_os = "macos")] + { + usage.ru_maxrss as u64 + } + #[cfg(not(target_os = "macos"))] + { + (usage.ru_maxrss as u64) * 1024 + } } const MATH_TABLES: &[&str] = &[ @@ -133,668 +193,412 @@ fn print_callback_timings(label: &str, stats: &Option, re } } -fn add_rule_timed>( - rule_name: &'static str, - rule_set: RuleSetId, - pat: impl Fn() -> P, - action: impl Fn(&PRRuleCtx, &P::Valued) + Send + Sync + 'static + Clone, - stats: Option, +fn register_rewrite_rules( + rs: RuleSetId, + sub_self: &'static str, + mul_distrib: &'static str, + add_factor: &'static str, + mul_pow_combine: &'static str, ) { - MyTxMath::add_rule(rule_name, rule_set, pat, move |ctx, pat| { - if stats.is_some() { - let t = Instant::now(); - action(ctx, pat); - record_callback_timing(&stats, rule_name, t.elapsed()); - } else { - action(ctx, pat); - } - }); -} - -#[eggplant::pat_vars] -struct AddCommPat { - a: Math, - b: Math, - add: MAdd, -} - -fn add_comm_pat() -> AddCommPat { - let a = Math::query_leaf(); - let b = Math::query_leaf(); - let add = MAdd::query(&a, &b); - AddCommPat::new(a, b, add) -} - -#[eggplant::pat_vars] -struct MulCommPat { - a: Math, - b: Math, - mul: MMul, -} - -fn mul_comm_pat() -> MulCommPat { - let a = Math::query_leaf(); - let b = Math::query_leaf(); - let mul = MMul::query(&a, &b); - MulCommPat::new(a, b, mul) -} - -#[eggplant::pat_vars] -struct AddAssocPat { - a: Math, - b: Math, - c: Math, - add_outer: MAdd, -} - -fn add_assoc_pat() -> AddAssocPat { - let a = Math::query_leaf(); - let b = Math::query_leaf(); - let c = Math::query_leaf(); - let add_inner = MAdd::query(&b, &c); - let add_outer = MAdd::query(&a, &add_inner); - AddAssocPat::new(a, b, c, add_outer) -} - -#[eggplant::pat_vars] -struct MulAssocPat { - a: Math, - b: Math, - c: Math, - mul_outer: MMul, -} - -fn mul_assoc_pat() -> MulAssocPat { - let a = Math::query_leaf(); - let b = Math::query_leaf(); - let c = Math::query_leaf(); - let mul_inner = MMul::query(&b, &c); - let mul_outer = MMul::query(&a, &mul_inner); - MulAssocPat::new(a, b, c, mul_outer) -} - -#[eggplant::pat_vars] -struct SubToAddNegPat { - a: Math, - b: Math, - sub: MSub, -} - -fn sub_to_add_neg_pat() -> SubToAddNegPat { - let a = Math::query_leaf(); - let b = Math::query_leaf(); - let sub = MSub::query(&a, &b); - SubToAddNegPat::new(a, b, sub) -} - -#[eggplant::pat_vars] -struct AddZeroPat { - a: Math, - z: MConst, - add: MAdd, -} - -fn add_zero_pat() -> AddZeroPat { - let a = Math::query_leaf(); - let z = MConst::query(); - let add = MAdd::query(&a, &z); - let constraint = z.handle_n().eq(&0_i64); - AddZeroPat::new(a, z, add).assert(constraint) -} - -#[eggplant::pat_vars] -struct MulZeroPat { - a: Math, - z: MConst, - mul: MMul, -} - -fn mul_zero_pat() -> MulZeroPat { - let a = Math::query_leaf(); - let z = MConst::query(); - let mul = MMul::query(&a, &z); - let constraint = z.handle_n().eq(&0_i64); - MulZeroPat::new(a, z, mul).assert(constraint) -} - -#[eggplant::pat_vars] -struct MulOnePat { - a: Math, - o: MConst, - mul: MMul, -} - -fn mul_one_pat() -> MulOnePat { - let a = Math::query_leaf(); - let o = MConst::query(); - let mul = MMul::query(&a, &o); - let constraint = o.handle_n().eq(&1_i64); - MulOnePat::new(a, o, mul).assert(constraint) -} - -#[eggplant::pat_vars] -struct SubSelfZeroPat { - a: Math, - sub: MSub, -} - -fn sub_self_zero_pat() -> SubSelfZeroPat { - let a = Math::query_leaf(); - let b = Math::query_leaf(); - let sub = MSub::query(&a, &b); - let constraint = a.handle().eq(&b.handle()); - SubSelfZeroPat::new(a, sub).assert(constraint) -} - -#[eggplant::pat_vars] -struct MulDistribPat { - a: Math, - b: Math, - c: Math, - mul: MMul, -} - -fn mul_distrib_pat() -> MulDistribPat { - let a = Math::query_leaf(); - let b = Math::query_leaf(); - let c = Math::query_leaf(); - let add = MAdd::query(&b, &c); - let mul = MMul::query(&a, &add); - MulDistribPat::new(a, b, c, mul) -} - -#[eggplant::pat_vars] -struct AddFactorPat { - a: Math, - b: Math, - c: Math, - add: MAdd, -} - -fn add_factor_pat() -> AddFactorPat { - let a = Math::query_leaf(); - let b = Math::query_leaf(); - let c = Math::query_leaf(); - let mul1 = MMul::query(&a, &b); - let mul2 = MMul::query(&a, &c); - let add = MAdd::query(&mul1, &mul2); - AddFactorPat::new(a, b, c, add) -} - -#[eggplant::pat_vars] -struct MulPowCombinePat { - a: Math, - b: Math, - c: Math, - mul: MMul, -} - -fn mul_pow_combine_pat() -> MulPowCombinePat { - let a = Math::query_leaf(); - let b = Math::query_leaf(); - let c = Math::query_leaf(); - let p1 = MPow::query(&a, &b); - let p2 = MPow::query(&a, &c); - let mul = MMul::query(&p1, &p2); - MulPowCombinePat::new(a, b, c, mul) -} - -#[eggplant::pat_vars] -struct PowOnePat { - x: Math, - o: MConst, - pow: MPow, -} - -fn pow_one_pat() -> PowOnePat { - let x = Math::query_leaf(); - let o = MConst::query(); - let pow = MPow::query(&x, &o); - let constraint = o.handle_n().eq(&1_i64); - PowOnePat::new(x, o, pow).assert(constraint) -} - -#[eggplant::pat_vars] -struct PowTwoPat { - x: Math, - t: MConst, - pow: MPow, -} - -fn pow_two_pat() -> PowTwoPat { - let x = Math::query_leaf(); - let t = MConst::query(); - let pow = MPow::query(&x, &t); - let constraint = t.handle_n().eq(&2_i64); - PowTwoPat::new(x, t, pow).assert(constraint) -} - -#[eggplant::pat_vars] -struct DiffAddPat { - x: Math, - a: Math, - b: Math, - diff: MDiff, -} - -fn diff_add_pat() -> DiffAddPat { - let x = Math::query_leaf(); - let a = Math::query_leaf(); - let b = Math::query_leaf(); - let add = MAdd::query(&a, &b); - let diff = MDiff::query(&x, &add); - DiffAddPat::new(x, a, b, diff) -} - -#[eggplant::pat_vars] -struct DiffMulPat { - x: Math, - a: Math, - b: Math, - diff: MDiff, -} - -fn diff_mul_pat() -> DiffMulPat { - let x = Math::query_leaf(); - let a = Math::query_leaf(); - let b = Math::query_leaf(); - let mul = MMul::query(&a, &b); - let diff = MDiff::query(&x, &mul); - DiffMulPat::new(x, a, b, diff) -} - -#[eggplant::pat_vars] -struct DiffSinPat { - x: Math, - diff: MDiff, -} - -fn diff_sin_pat() -> DiffSinPat { - let x = Math::query_leaf(); - let sin = MSin::query(&x); - let diff = MDiff::query(&x, &sin); - DiffSinPat::new(x, diff) -} - -#[eggplant::pat_vars] -struct DiffCosPat { - x: Math, - diff: MDiff, -} - -fn diff_cos_pat() -> DiffCosPat { - let x = Math::query_leaf(); - let cos = MCos::query(&x); - let diff = MDiff::query(&x, &cos); - DiffCosPat::new(x, diff) -} - -#[eggplant::pat_vars] -struct IntOnePat { - x: Math, - one: MConst, - integ: MIntegral, -} - -fn int_one_pat() -> IntOnePat { - let x = Math::query_leaf(); - let one = MConst::query(); - let integ = MIntegral::query(&one, &x); - let constraint = one.handle_n().eq(&1_i64); - IntOnePat::new(x, one, integ).assert(constraint) -} - -#[eggplant::pat_vars] -struct IntCosPat { - x: Math, - integ: MIntegral, -} - -fn int_cos_pat() -> IntCosPat { - let x = Math::query_leaf(); - let cos = MCos::query(&x); - let integ = MIntegral::query(&cos, &x); - IntCosPat::new(x, integ) -} - -#[eggplant::pat_vars] -struct IntSinPat { - x: Math, - integ: MIntegral, -} - -fn int_sin_pat() -> IntSinPat { - let x = Math::query_leaf(); - let sin = MSin::query(&x); - let integ = MIntegral::query(&sin, &x); - IntSinPat::new(x, integ) -} - -#[eggplant::pat_vars] -struct IntAddPat { - f: Math, - g: Math, - x: Math, - integ: MIntegral, -} - -fn int_add_pat() -> IntAddPat { - let f = Math::query_leaf(); - let g = Math::query_leaf(); - let x = Math::query_leaf(); - let add = MAdd::query(&f, &g); - let integ = MIntegral::query(&add, &x); - IntAddPat::new(f, g, x, integ) -} - -#[eggplant::pat_vars] -struct IntSubPat { - f: Math, - g: Math, - x: Math, - integ: MIntegral, -} - -fn int_sub_pat() -> IntSubPat { - let f = Math::query_leaf(); - let g = Math::query_leaf(); - let x = Math::query_leaf(); - let sub = MSub::query(&f, &g); - let integ = MIntegral::query(&sub, &x); - IntSubPat::new(f, g, x, integ) -} - -#[eggplant::pat_vars] -struct IntMulPat { - a: Math, - b: Math, - x: Math, - integ: MIntegral, -} - -fn int_mul_pat() -> IntMulPat { - let a = Math::query_leaf(); - let b = Math::query_leaf(); - let x = Math::query_leaf(); - let mul = MMul::query(&a, &b); - let integ = MIntegral::query(&mul, &x); - IntMulPat::new(a, b, x, integ) -} - -pub fn run_and_collect_stats(breakdown: bool) -> MathMicrobenchmarkStats { - let t_total = Instant::now(); - let seed_callback_stats = breakdown.then(|| Arc::new(Mutex::new(BTreeMap::new()))); - let rewrite_callback_stats = breakdown.then(|| Arc::new(Mutex::new(BTreeMap::new()))); - - let t = Instant::now(); - MyTxMath::reset_for_bench(); - if breakdown { - eprintln!( - "[bench-breakdown] math-microbenchmark reset_for_bench: {:?}", - t.elapsed() - ); - } - - // Seed ground terms (ports `tests/math-microbenchmark.egg`). - let t_seed_setup = Instant::now(); - let seed = MyTxMath::new_ruleset("math_microbenchmark_seed"); - add_rule_timed( - "math_microbenchmark_seed", - seed, - || { - #[eggplant::pat_vars_catch] - struct Unit {} - }, - |ctx, _pat| { - let x = ctx.insert_m_var("x".to_owned()); - let y = ctx.insert_m_var("y".to_owned()); - let five = ctx.insert_m_var("five".to_owned()); - - // (Integral (Ln (Var "x")) (Var "x")) - let ln_x = ctx.insert_m_ln(x.clone()); - ctx.insert_m_integral(ln_x, x.clone()); - - // (Integral (Add (Var "x") (Cos (Var "x"))) (Var "x")) - let cos_x = ctx.insert_m_cos(x.clone()); - let add_x_cos_x = ctx.insert_m_add(x.clone(), cos_x); - ctx.insert_m_integral(add_x_cos_x, x.clone()); - - // (Integral (Mul (Cos (Var "x")) (Var "x")) (Var "x")) - let cos_x = ctx.insert_m_cos(x.clone()); - let mul_cos_x_x = ctx.insert_m_mul(cos_x, x.clone()); - ctx.insert_m_integral(mul_cos_x_x, x.clone()); - - // (Diff (Var "x") (Add (Const 1) (Mul (Const 2) (Var "x")))) - let c1 = ctx.insert_m_const(1); - let c2 = ctx.insert_m_const(2); - let mul_2_x = ctx.insert_m_mul(c2, x.clone()); - let add_1_2x = ctx.insert_m_add(c1, mul_2_x); - ctx.insert_m_diff(x.clone(), add_1_2x); - - // (Diff (Var "x") (Sub (Pow (Var "x") (Const 3)) - // (Mul (Const 7) (Pow (Var "x") (Const 2))))) - let c3 = ctx.insert_m_const(3); - let c7 = ctx.insert_m_const(7); - let pow_x_3 = ctx.insert_m_pow(x.clone(), c3); - let pow_x_2 = ctx.insert_m_pow(x.clone(), ctx.insert_m_const(2)); - let mul_7_pow = ctx.insert_m_mul(c7, pow_x_2); - let sub_pow = ctx.insert_m_sub(pow_x_3, mul_7_pow); - ctx.insert_m_diff(x.clone(), sub_pow); - - // (Add (Mul (Var "y") (Add (Var "x") (Var "y"))) - // (Sub (Add (Var "x") (Const 2)) (Add (Var "x") (Var "x")))) - let add_x_y = ctx.insert_m_add(x.clone(), y.clone()); - let mul_y_add = ctx.insert_m_mul(y.clone(), add_x_y); - let add_x_2 = ctx.insert_m_add(x.clone(), ctx.insert_m_const(2)); - let add_x_x = ctx.insert_m_add(x.clone(), x.clone()); - let sub_add = ctx.insert_m_sub(add_x_2, add_x_x); - ctx.insert_m_add(mul_y_add, sub_add); - - // (Div (Const 1) (Sub (Div (Add (Const 1) (Sqrt (Var "five"))) (Const 2)) - // (Div (Sub (Const 1) (Sqrt (Var "five"))) (Const 2)))) - let c1 = ctx.insert_m_const(1); - let c2 = ctx.insert_m_const(2); - let sqrt_five = ctx.insert_m_sqrt(five.clone()); - let add_1_sqrt = ctx.insert_m_add(c1, sqrt_five.clone()); - let div_add = ctx.insert_m_div(add_1_sqrt, c2); - let sub_1_sqrt = ctx.insert_m_sub(ctx.insert_m_const(1), sqrt_five); - let div_sub = ctx.insert_m_div(sub_1_sqrt, ctx.insert_m_const(2)); - let denom = ctx.insert_m_sub(div_add, div_sub); - ctx.insert_m_div(ctx.insert_m_const(1), denom); - }, - seed_callback_stats.clone(), - ); - if breakdown { - eprintln!( - "[bench-breakdown] math-microbenchmark seed add_rule: {:?}", - t_seed_setup.elapsed() - ); - } - - let t_seed_run = Instant::now(); - let seed_report = MyTxMath::run_ruleset(seed, RunConfig::Once); - if breakdown { - eprintln!( - "[bench-breakdown] math-microbenchmark seed run_ruleset: {:?}", - t_seed_run.elapsed() - ); - print_callback_timings( - "math-microbenchmark seed", - &seed_callback_stats, - &seed_report, - ); - } - - // Rewrite rules (ports `tests/math-microbenchmark.egg` rewrites). - let t_rules_setup = Instant::now(); - let rs = MyTxMath::new_ruleset("math_microbenchmark_rules"); - - add_rule_timed( + MyTxMath::add_rule( "add_comm", rs, - add_comm_pat, + || { + let a = Math::query_leaf(); + let b = Math::query_leaf(); + let add = MAdd::query(&a, &b); + #[eggplant::pat_vars] + struct Pat { + a: Math, + b: Math, + add: MAdd, + } + Pat::new(a, b, add) + }, |ctx, pat| { let rhs = ctx.insert_m_add(pat.b, pat.a); ctx.union(pat.add, rhs); }, - rewrite_callback_stats.clone(), ); - add_rule_timed( + MyTxMath::add_rule( "mul_comm", rs, - mul_comm_pat, + || { + let a = Math::query_leaf(); + let b = Math::query_leaf(); + let mul = MMul::query(&a, &b); + #[eggplant::pat_vars] + struct Pat { + a: Math, + b: Math, + mul: MMul, + } + Pat::new(a, b, mul) + }, |ctx, pat| { let rhs = ctx.insert_m_mul(pat.b, pat.a); ctx.union(pat.mul, rhs); }, - rewrite_callback_stats.clone(), ); - add_rule_timed( + MyTxMath::add_rule( "add_assoc", rs, - add_assoc_pat, + || { + let a = Math::query_leaf(); + let b = Math::query_leaf(); + let c = Math::query_leaf(); + let add_inner = MAdd::query(&b, &c); + let add_outer = MAdd::query(&a, &add_inner); + #[eggplant::pat_vars] + struct Pat { + a: Math, + b: Math, + c: Math, + add_outer: MAdd, + } + Pat::new(a, b, c, add_outer) + }, |ctx, pat| { let ab = ctx.insert_m_add(pat.a, pat.b); let rhs = ctx.insert_m_add(ab, pat.c); ctx.union(pat.add_outer, rhs); }, - rewrite_callback_stats.clone(), ); - add_rule_timed( + MyTxMath::add_rule( "mul_assoc", rs, - mul_assoc_pat, + || { + let a = Math::query_leaf(); + let b = Math::query_leaf(); + let c = Math::query_leaf(); + let mul_inner = MMul::query(&b, &c); + let mul_outer = MMul::query(&a, &mul_inner); + #[eggplant::pat_vars] + struct Pat { + a: Math, + b: Math, + c: Math, + mul_outer: MMul, + } + Pat::new(a, b, c, mul_outer) + }, |ctx, pat| { let ab = ctx.insert_m_mul(pat.a, pat.b); let rhs = ctx.insert_m_mul(ab, pat.c); ctx.union(pat.mul_outer, rhs); }, - rewrite_callback_stats.clone(), ); - - add_rule_timed( + MyTxMath::add_rule( "sub_to_add_neg", rs, - sub_to_add_neg_pat, + || { + let a = Math::query_leaf(); + let b = Math::query_leaf(); + let sub = MSub::query(&a, &b); + #[eggplant::pat_vars] + struct Pat { + a: Math, + b: Math, + sub: MSub, + } + Pat::new(a, b, sub) + }, |ctx, pat| { let neg1 = ctx.insert_m_const(-1); let neg_b = ctx.insert_m_mul(neg1, pat.b); let rhs = ctx.insert_m_add(pat.a, neg_b); ctx.union(pat.sub, rhs); }, - rewrite_callback_stats.clone(), ); - - add_rule_timed( + MyTxMath::add_rule( "add_zero", rs, - add_zero_pat, + || { + let a = Math::query_leaf(); + let z = MConst::query(); + let add = MAdd::query(&a, &z); + let is_zero = z.handle_n().eq(&0_i64); + #[eggplant::pat_vars] + struct Pat { + a: Math, + z: MConst, + add: MAdd, + } + Pat::new(a, z, add).assert(is_zero) + }, |ctx, pat| { ctx.union(pat.add, pat.a); }, - rewrite_callback_stats.clone(), ); - add_rule_timed( + MyTxMath::add_rule( "mul_zero", rs, - mul_zero_pat, + || { + let a = Math::query_leaf(); + let z = MConst::query(); + let mul = MMul::query(&a, &z); + let is_zero = z.handle_n().eq(&0_i64); + #[eggplant::pat_vars] + struct Pat { + a: Math, + z: MConst, + mul: MMul, + } + Pat::new(a, z, mul).assert(is_zero) + }, |ctx, pat| { ctx.union(pat.mul, pat.z); }, - rewrite_callback_stats.clone(), ); - add_rule_timed( + MyTxMath::add_rule( "mul_one", rs, - mul_one_pat, + || { + let a = Math::query_leaf(); + let o = MConst::query(); + let mul = MMul::query(&a, &o); + let is_one = o.handle_n().eq(&1_i64); + #[eggplant::pat_vars] + struct Pat { + a: Math, + o: MConst, + mul: MMul, + } + Pat::new(a, o, mul).assert(is_one) + }, |ctx, pat| { ctx.union(pat.mul, pat.a); }, - rewrite_callback_stats.clone(), ); - - add_rule_timed( - "sub_self_zero", + MyTxMath::add_rule( + sub_self, rs, - sub_self_zero_pat, + || { + let a = Math::query_leaf(); + let b = Math::query_leaf(); + let sub = MSub::query(&a, &b); + let same_terms = a.handle().eq(&b.handle()); + #[eggplant::pat_vars] + struct Pat { + a: Math, + sub: MSub, + } + Pat::new(a, sub).assert(same_terms) + }, |ctx, pat| { let z = ctx.insert_m_const(0); ctx.union(pat.sub, z); }, - rewrite_callback_stats.clone(), ); - - add_rule_timed( - "mul_distrib", + MyTxMath::add_rule( + mul_distrib, rs, - mul_distrib_pat, + || { + let a = Math::query_leaf(); + let b = Math::query_leaf(); + let c = Math::query_leaf(); + let add = MAdd::query(&b, &c); + let mul = MMul::query(&a, &add); + #[eggplant::pat_vars] + struct Pat { + a: Math, + b: Math, + c: Math, + mul: MMul, + } + Pat::new(a, b, c, mul) + }, |ctx, pat| { let ab = ctx.insert_m_mul(pat.a, pat.b); let ac = ctx.insert_m_mul(pat.a, pat.c); let rhs = ctx.insert_m_add(ab, ac); ctx.union(pat.mul, rhs); }, - rewrite_callback_stats.clone(), ); - add_rule_timed( - "add_factor", + MyTxMath::add_rule( + add_factor, rs, - add_factor_pat, + || { + let a = Math::query_leaf(); + let b = Math::query_leaf(); + let c = Math::query_leaf(); + let mul1 = MMul::query(&a, &b); + let mul2 = MMul::query(&a, &c); + let add = MAdd::query(&mul1, &mul2); + #[eggplant::pat_vars] + struct Pat { + a: Math, + b: Math, + c: Math, + add: MAdd, + } + Pat::new(a, b, c, add) + }, |ctx, pat| { let bc = ctx.insert_m_add(pat.b, pat.c); let rhs = ctx.insert_m_mul(pat.a, bc); ctx.union(pat.add, rhs); }, - rewrite_callback_stats.clone(), ); - - add_rule_timed( - "mul_pow_combine", + MyTxMath::add_rule( + mul_pow_combine, rs, - mul_pow_combine_pat, + || { + let a = Math::query_leaf(); + let b = Math::query_leaf(); + let c = Math::query_leaf(); + let p1 = MPow::query(&a, &b); + let p2 = MPow::query(&a, &c); + let mul = MMul::query(&p1, &p2); + #[eggplant::pat_vars] + struct Pat { + a: Math, + b: Math, + c: Math, + mul: MMul, + } + Pat::new(a, b, c, mul) + }, |ctx, pat| { let bc = ctx.insert_m_add(pat.b, pat.c); let rhs = ctx.insert_m_pow(pat.a, bc); ctx.union(pat.mul, rhs); }, - rewrite_callback_stats.clone(), ); - add_rule_timed( - "pow_one", + MyTxMath::add_rule( + "div_add_distrib", rs, - pow_one_pat, + || { + let a = Math::query_leaf(); + let b = Math::query_leaf(); + let c = Math::query_leaf(); + let add = MAdd::query(&a, &b); + let div = MDiv::query(&add, &c); + #[eggplant::pat_vars] + struct Pat { + a: Math, + b: Math, + c: Math, + div: MDiv, + } + Pat::new(a, b, c, div) + }, |ctx, pat| { - ctx.union(pat.pow, pat.x); + let a_div_c = ctx.insert_m_div(pat.a, pat.c); + let b_div_c = ctx.insert_m_div(pat.b, pat.c); + let rhs = ctx.insert_m_add(a_div_c, b_div_c); + ctx.union(pat.div, rhs); }, - rewrite_callback_stats.clone(), ); - add_rule_timed( - "pow_two", + MyTxMath::add_rule( + "div_sub_distrib", rs, - pow_two_pat, - |ctx, pat| { + || { + let a = Math::query_leaf(); + let b = Math::query_leaf(); + let c = Math::query_leaf(); + let sub = MSub::query(&a, &b); + let div = MDiv::query(&sub, &c); + #[eggplant::pat_vars] + struct Pat { + a: Math, + b: Math, + c: Math, + div: MDiv, + } + Pat::new(a, b, c, div) + }, + |ctx, pat| { + let a_div_c = ctx.insert_m_div(pat.a, pat.c); + let b_div_c = ctx.insert_m_div(pat.b, pat.c); + let rhs = ctx.insert_m_sub(a_div_c, b_div_c); + ctx.union(pat.div, rhs); + }, + ); + MyTxMath::add_rule( + "pow_one", + rs, + || { + let x = Math::query_leaf(); + let o = MConst::query(); + let pow = MPow::query(&x, &o); + let is_one = o.handle_n().eq(&1_i64); + #[eggplant::pat_vars] + struct Pat { + x: Math, + o: MConst, + pow: MPow, + } + Pat::new(x, o, pow).assert(is_one) + }, + |ctx, pat| { + ctx.union(pat.pow, pat.x); + }, + ); + MyTxMath::add_rule( + "pow_two", + rs, + || { + let x = Math::query_leaf(); + let t = MConst::query(); + let pow = MPow::query(&x, &t); + let is_two = t.handle_n().eq(&2_i64); + #[eggplant::pat_vars] + struct Pat { + x: Math, + t: MConst, + pow: MPow, + } + Pat::new(x, t, pow).assert(is_two) + }, + |ctx, pat| { let rhs = ctx.insert_m_mul(pat.x, pat.x); ctx.union(pat.pow, rhs); }, - rewrite_callback_stats.clone(), ); - - add_rule_timed( + MyTxMath::add_rule( "diff_add", rs, - diff_add_pat, + || { + let x = Math::query_leaf(); + let a = Math::query_leaf(); + let b = Math::query_leaf(); + let add = MAdd::query(&a, &b); + let diff = MDiff::query(&x, &add); + #[eggplant::pat_vars] + struct Pat { + x: Math, + a: Math, + b: Math, + diff: MDiff, + } + Pat::new(x, a, b, diff) + }, |ctx, pat| { let da = ctx.insert_m_diff(pat.x, pat.a); let db = ctx.insert_m_diff(pat.x, pat.b); let rhs = ctx.insert_m_add(da, db); ctx.union(pat.diff, rhs); }, - rewrite_callback_stats.clone(), ); - add_rule_timed( + MyTxMath::add_rule( "diff_mul", rs, - diff_mul_pat, + || { + let x = Math::query_leaf(); + let a = Math::query_leaf(); + let b = Math::query_leaf(); + let mul = MMul::query(&a, &b); + let diff = MDiff::query(&x, &mul); + #[eggplant::pat_vars] + struct Pat { + x: Math, + a: Math, + b: Math, + diff: MDiff, + } + Pat::new(x, a, b, diff) + }, |ctx, pat| { let db = ctx.insert_m_diff(pat.x, pat.b); let da = ctx.insert_m_diff(pat.x, pat.a); @@ -803,90 +607,175 @@ pub fn run_and_collect_stats(breakdown: bool) -> MathMicrobenchmarkStats { let rhs = ctx.insert_m_add(a_db, b_da); ctx.union(pat.diff, rhs); }, - rewrite_callback_stats.clone(), ); - add_rule_timed( + MyTxMath::add_rule( "diff_sin", rs, - diff_sin_pat, + || { + let x = Math::query_leaf(); + let sin = MSin::query(&x); + let diff = MDiff::query(&x, &sin); + #[eggplant::pat_vars] + struct Pat { + x: Math, + diff: MDiff, + } + Pat::new(x, diff) + }, |ctx, pat| { let rhs = ctx.insert_m_cos(pat.x); ctx.union(pat.diff, rhs); }, - rewrite_callback_stats.clone(), ); - add_rule_timed( + MyTxMath::add_rule( "diff_cos", rs, - diff_cos_pat, + || { + let x = Math::query_leaf(); + let cos = MCos::query(&x); + let diff = MDiff::query(&x, &cos); + #[eggplant::pat_vars] + struct Pat { + x: Math, + diff: MDiff, + } + Pat::new(x, diff) + }, |ctx, pat| { let neg1 = ctx.insert_m_const(-1); let sin = ctx.insert_m_sin(pat.x); let rhs = ctx.insert_m_mul(neg1, sin); ctx.union(pat.diff, rhs); }, - rewrite_callback_stats.clone(), ); - - add_rule_timed( + MyTxMath::add_rule( "int_one", rs, - int_one_pat, + || { + let x = Math::query_leaf(); + let one = MConst::query(); + let integ = MIntegral::query(&one, &x); + let is_one = one.handle_n().eq(&1_i64); + #[eggplant::pat_vars] + struct Pat { + x: Math, + one: MConst, + integ: MIntegral, + } + Pat::new(x, one, integ).assert(is_one) + }, |ctx, pat| { ctx.union(pat.integ, pat.x); }, - rewrite_callback_stats.clone(), ); - add_rule_timed( + MyTxMath::add_rule( "int_cos", rs, - int_cos_pat, + || { + let x = Math::query_leaf(); + let cos = MCos::query(&x); + let integ = MIntegral::query(&cos, &x); + #[eggplant::pat_vars] + struct Pat { + x: Math, + integ: MIntegral, + } + Pat::new(x, integ) + }, |ctx, pat| { let rhs = ctx.insert_m_sin(pat.x); ctx.union(pat.integ, rhs); }, - rewrite_callback_stats.clone(), ); - add_rule_timed( + MyTxMath::add_rule( "int_sin", rs, - int_sin_pat, + || { + let x = Math::query_leaf(); + let sin = MSin::query(&x); + let integ = MIntegral::query(&sin, &x); + #[eggplant::pat_vars] + struct Pat { + x: Math, + integ: MIntegral, + } + Pat::new(x, integ) + }, |ctx, pat| { let neg1 = ctx.insert_m_const(-1); let cos = ctx.insert_m_cos(pat.x); let rhs = ctx.insert_m_mul(neg1, cos); ctx.union(pat.integ, rhs); }, - rewrite_callback_stats.clone(), ); - add_rule_timed( + MyTxMath::add_rule( "int_add", rs, - int_add_pat, + || { + let f = Math::query_leaf(); + let g = Math::query_leaf(); + let x = Math::query_leaf(); + let add = MAdd::query(&f, &g); + let integ = MIntegral::query(&add, &x); + #[eggplant::pat_vars] + struct Pat { + f: Math, + g: Math, + x: Math, + integ: MIntegral, + } + Pat::new(f, g, x, integ) + }, |ctx, pat| { let i_f = ctx.insert_m_integral(pat.f, pat.x); let i_g = ctx.insert_m_integral(pat.g, pat.x); let rhs = ctx.insert_m_add(i_f, i_g); ctx.union(pat.integ, rhs); }, - rewrite_callback_stats.clone(), ); - add_rule_timed( + MyTxMath::add_rule( "int_sub", rs, - int_sub_pat, + || { + let f = Math::query_leaf(); + let g = Math::query_leaf(); + let x = Math::query_leaf(); + let sub = MSub::query(&f, &g); + let integ = MIntegral::query(&sub, &x); + #[eggplant::pat_vars] + struct Pat { + f: Math, + g: Math, + x: Math, + integ: MIntegral, + } + Pat::new(f, g, x, integ) + }, |ctx, pat| { let i_f = ctx.insert_m_integral(pat.f, pat.x); let i_g = ctx.insert_m_integral(pat.g, pat.x); let rhs = ctx.insert_m_sub(i_f, i_g); ctx.union(pat.integ, rhs); }, - rewrite_callback_stats.clone(), ); - add_rule_timed( + MyTxMath::add_rule( "int_mul", rs, - int_mul_pat, + || { + let a = Math::query_leaf(); + let b = Math::query_leaf(); + let x = Math::query_leaf(); + let mul = MMul::query(&a, &b); + let integ = MIntegral::query(&mul, &x); + #[eggplant::pat_vars] + struct Pat { + a: Math, + b: Math, + x: Math, + integ: MIntegral, + } + Pat::new(a, b, x, integ) + }, |ctx, pat| { let i_b = ctx.insert_m_integral(pat.b, pat.x); let a_i_b = ctx.insert_m_mul(pat.a, i_b); @@ -896,9 +785,122 @@ pub fn run_and_collect_stats(breakdown: bool) -> MathMicrobenchmarkStats { let rhs = ctx.insert_m_sub(a_i_b, i2); ctx.union(pat.integ, rhs); }, - rewrite_callback_stats.clone(), ); +} + +pub fn run_and_collect_stats(breakdown: bool) -> MathMicrobenchmarkStats { + let t_total = Instant::now(); + let seed_callback_stats = breakdown.then(|| Arc::new(Mutex::new(BTreeMap::new()))); + let rewrite_callback_stats = breakdown.then(|| Arc::new(Mutex::new(BTreeMap::new()))); + + let t = Instant::now(); + MyTxMath::reset_for_bench(); + if breakdown { + eprintln!( + "[bench-breakdown] math-microbenchmark reset_for_bench: {:?}", + t.elapsed() + ); + } + + // Seed ground terms (ports `tests/math-microbenchmark.egg`). + let t_seed_setup = Instant::now(); + let seed = MyTxMath::new_ruleset("math_microbenchmark_seed"); + MyTxMath::add_rule( + "math_microbenchmark_seed", + seed, + || { + #[eggplant::pat_vars_catch] + struct Unit {} + }, + |ctx, _pat| { + let x = ctx.insert_m_var("x".to_owned()); + let y = ctx.insert_m_var("y".to_owned()); + let five = ctx.insert_m_var("five".to_owned()); + + // (Integral (Ln (Var "x")) (Var "x")) + let ln_x = ctx.insert_m_ln(x.clone()); + ctx.insert_m_integral(ln_x, x.clone()); + + // (Integral (Add (Var "x") (Cos (Var "x"))) (Var "x")) + let cos_x = ctx.insert_m_cos(x.clone()); + let add_x_cos_x = ctx.insert_m_add(x.clone(), cos_x); + ctx.insert_m_integral(add_x_cos_x, x.clone()); + + // (Integral (Mul (Cos (Var "x")) (Var "x")) (Var "x")) + let cos_x = ctx.insert_m_cos(x.clone()); + let mul_cos_x_x = ctx.insert_m_mul(cos_x, x.clone()); + ctx.insert_m_integral(mul_cos_x_x, x.clone()); + + // (Diff (Var "x") (Add (Const 1) (Mul (Const 2) (Var "x")))) + let c1 = ctx.insert_m_const(1); + let c2 = ctx.insert_m_const(2); + let mul_2_x = ctx.insert_m_mul(c2, x.clone()); + let add_1_2x = ctx.insert_m_add(c1, mul_2_x); + ctx.insert_m_diff(x.clone(), add_1_2x); + + // (Diff (Var "x") (Sub (Pow (Var "x") (Const 3)) + // (Mul (Const 7) (Pow (Var "x") (Const 2))))) + let c3 = ctx.insert_m_const(3); + let c7 = ctx.insert_m_const(7); + let pow_x_3 = ctx.insert_m_pow(x.clone(), c3); + let pow_x_2 = ctx.insert_m_pow(x.clone(), ctx.insert_m_const(2)); + let mul_7_pow = ctx.insert_m_mul(c7, pow_x_2); + let sub_pow = ctx.insert_m_sub(pow_x_3, mul_7_pow); + ctx.insert_m_diff(x.clone(), sub_pow); + + // (Add (Mul (Var "y") (Add (Var "x") (Var "y"))) + // (Sub (Add (Var "x") (Const 2)) (Add (Var "x") (Var "x")))) + let add_x_y = ctx.insert_m_add(x.clone(), y.clone()); + let mul_y_add = ctx.insert_m_mul(y.clone(), add_x_y); + let add_x_2 = ctx.insert_m_add(x.clone(), ctx.insert_m_const(2)); + let add_x_x = ctx.insert_m_add(x.clone(), x.clone()); + let sub_add = ctx.insert_m_sub(add_x_2, add_x_x); + ctx.insert_m_add(mul_y_add, sub_add); + + // (Div (Const 1) (Sub (Div (Add (Const 1) (Sqrt (Var "five"))) (Const 2)) + // (Div (Sub (Const 1) (Sqrt (Var "five"))) (Const 2)))) + let c1 = ctx.insert_m_const(1); + let c2 = ctx.insert_m_const(2); + let sqrt_five = ctx.insert_m_sqrt(five.clone()); + let add_1_sqrt = ctx.insert_m_add(c1, sqrt_five.clone()); + let div_add = ctx.insert_m_div(add_1_sqrt, c2); + let sub_1_sqrt = ctx.insert_m_sub(ctx.insert_m_const(1), sqrt_five); + let div_sub = ctx.insert_m_div(sub_1_sqrt, ctx.insert_m_const(2)); + let denom = ctx.insert_m_sub(div_add, div_sub); + ctx.insert_m_div(ctx.insert_m_const(1), denom); + }, + ); + if breakdown { + eprintln!( + "[bench-breakdown] math-microbenchmark seed add_rule: {:?}", + t_seed_setup.elapsed() + ); + } + + let t_seed_run = Instant::now(); + let seed_report = MyTxMath::run_ruleset(seed, RunConfig::Once); + if breakdown { + eprintln!( + "[bench-breakdown] math-microbenchmark seed run_ruleset: {:?}", + t_seed_run.elapsed() + ); + print_callback_timings( + "math-microbenchmark seed", + &seed_callback_stats, + &seed_report, + ); + } + // Rewrite rules (ports `tests/math-microbenchmark.egg` rewrites). + let t_rules_setup = Instant::now(); + let rs = MyTxMath::new_ruleset("math_microbenchmark_rules"); + register_rewrite_rules( + rs, + "sub_self_zero", + "mul_distrib", + "add_factor", + "mul_pow_combine", + ); if breakdown { eprintln!( "[bench-breakdown] math-microbenchmark rewrites add_rule: {:?}", @@ -920,7 +922,205 @@ pub fn run_and_collect_stats(breakdown: bool) -> MathMicrobenchmarkStats { ); } - let egraph = MyTxMath::egraph(); + let egraph = ::egraph(); + let egraph = egraph.lock().unwrap(); + let stats = MathMicrobenchmarkStats { + elapsed: t_total.elapsed(), + total_num_tuples: egraph.num_tuples(), + table_sizes: MATH_TABLES + .iter() + .map(|table| (*table, egraph.get_size(table))) + .collect(), + max_rewrite_mem_gib: DEFAULT_RUN_RULESET_MEMORY_CAP_GIB, + rewrite_peak_memory_bytes: 0, + requested_rewrite_iters: 11, + executed_rewrite_iters: 11, + rewrite_stopped_early_due_to_memory_cap: false, + }; + if breakdown { + eprintln!( + "[bench-breakdown] math-microbenchmark total: {:?}", + t_total.elapsed() + ); + } + stats +} + +pub fn run_and_collect_stats_iters( + breakdown: bool, + rewrite_iters: usize, +) -> MathMicrobenchmarkStats { + run_and_collect_stats_iters_with_mem_cap( + breakdown, + rewrite_iters, + DEFAULT_RUN_RULESET_MEMORY_CAP_GIB, + ) +} + +pub fn run_and_collect_stats_iters_with_mem_cap( + breakdown: bool, + rewrite_iters: usize, + max_rewrite_mem_gib: u64, +) -> MathMicrobenchmarkStats { + let t_total = Instant::now(); + let seed_callback_stats = breakdown.then(|| Arc::new(Mutex::new(BTreeMap::new()))); + let rewrite_callback_stats = breakdown.then(|| Arc::new(Mutex::new(BTreeMap::new()))); + let max_rewrite_mem_bytes = max_rewrite_mem_gib + .saturating_mul(1024) + .saturating_mul(1024) + .saturating_mul(1024); + + let t = Instant::now(); + MyTxMath::reset_for_bench(); + if breakdown { + eprintln!( + "[bench-breakdown] math-microbenchmark reset_for_bench: {:?}", + t.elapsed() + ); + } + + let t_seed_setup = Instant::now(); + let seed = MyTxMath::new_ruleset("math_microbenchmark_seed"); + MyTxMath::add_rule( + "math_microbenchmark_seed", + seed, + || { + #[eggplant::pat_vars_catch] + struct Unit {} + }, + |ctx, _pat| { + let x = ctx.insert_m_var("x".to_owned()); + let y = ctx.insert_m_var("y".to_owned()); + let five = ctx.insert_m_var("five".to_owned()); + + let ln_x = ctx.insert_m_ln(x.clone()); + ctx.insert_m_integral(ln_x, x.clone()); + + let cos_x = ctx.insert_m_cos(x.clone()); + let add_x_cos_x = ctx.insert_m_add(x.clone(), cos_x); + ctx.insert_m_integral(add_x_cos_x, x.clone()); + + let cos_x = ctx.insert_m_cos(x.clone()); + let mul_cos_x_x = ctx.insert_m_mul(cos_x, x.clone()); + ctx.insert_m_integral(mul_cos_x_x, x.clone()); + + let c1 = ctx.insert_m_const(1); + let c2 = ctx.insert_m_const(2); + let mul_2_x = ctx.insert_m_mul(c2, x.clone()); + let add_1_2x = ctx.insert_m_add(c1, mul_2_x); + ctx.insert_m_diff(x.clone(), add_1_2x); + + let c3 = ctx.insert_m_const(3); + let c7 = ctx.insert_m_const(7); + let pow_x_3 = ctx.insert_m_pow(x.clone(), c3); + let pow_x_2 = ctx.insert_m_pow(x.clone(), ctx.insert_m_const(2)); + let mul_7_pow = ctx.insert_m_mul(c7, pow_x_2); + let sub_pow = ctx.insert_m_sub(pow_x_3, mul_7_pow); + ctx.insert_m_diff(x.clone(), sub_pow); + + let add_x_y = ctx.insert_m_add(x.clone(), y.clone()); + let mul_y_add = ctx.insert_m_mul(y.clone(), add_x_y); + let add_x_2 = ctx.insert_m_add(x.clone(), ctx.insert_m_const(2)); + let add_x_x = ctx.insert_m_add(x.clone(), x.clone()); + let sub_add = ctx.insert_m_sub(add_x_2, add_x_x); + ctx.insert_m_add(mul_y_add, sub_add); + + let c1 = ctx.insert_m_const(1); + let c2 = ctx.insert_m_const(2); + let sqrt_five = ctx.insert_m_sqrt(five.clone()); + let add_1_sqrt = ctx.insert_m_add(c1, sqrt_five.clone()); + let div_add = ctx.insert_m_div(add_1_sqrt, c2); + let sub_1_sqrt = ctx.insert_m_sub(ctx.insert_m_const(1), sqrt_five); + let div_sub = ctx.insert_m_div(sub_1_sqrt, ctx.insert_m_const(2)); + let denom = ctx.insert_m_sub(div_add, div_sub); + ctx.insert_m_div(ctx.insert_m_const(1), denom); + }, + ); + if breakdown { + eprintln!( + "[bench-breakdown] math-microbenchmark seed add_rule: {:?}", + t_seed_setup.elapsed() + ); + } + + let t_seed_run = Instant::now(); + let seed_report = MyTxMath::run_ruleset(seed, RunConfig::Once); + if breakdown { + eprintln!( + "[bench-breakdown] math-microbenchmark seed run_ruleset: {:?}", + t_seed_run.elapsed() + ); + print_callback_timings( + "math-microbenchmark seed", + &seed_callback_stats, + &seed_report, + ); + } + + let t_rules_setup = Instant::now(); + let rs = MyTxMath::new_ruleset("math_microbenchmark_rules"); + register_rewrite_rules( + rs, + "sub_self", + "distribute_mul", + "factor_mul", + "pow_mul_same_base", + ); + if breakdown { + eprintln!( + "[bench-breakdown] math-microbenchmark rewrites add_rule: {:?}", + t_rules_setup.elapsed() + ); + } + + let t_rules_run = Instant::now(); + let rewrite_peak_before = current_peak_memory_bytes(); + let mut rewrite_report = RunReport::default(); + let mut executed_rewrite_iters = 0usize; + let mut rewrite_stopped_early_due_to_memory_cap = false; + for _ in 0..rewrite_iters { + let report = MyTxMath::run_ruleset(rs, RunConfig::Once); + rewrite_report.union(report); + executed_rewrite_iters += 1; + let current_peak = current_peak_memory_bytes(); + let tuple_count = { + let egraph = ::egraph(); + let egraph = egraph.lock().unwrap(); + egraph.num_tuples() + }; + eprintln!( + "[math-microbenchmark] completed rewrite iteration {}/{}, tuples={}, peak_mem={:.2} MiB", + executed_rewrite_iters, + rewrite_iters, + tuple_count, + current_peak as f64 / (1024.0 * 1024.0), + ); + if current_peak > max_rewrite_mem_bytes { + rewrite_stopped_early_due_to_memory_cap = true; + eprintln!( + "[math-microbenchmark] stopping early after iteration {} because peak memory {:.2} MiB exceeded configured cap {:.2} MiB", + executed_rewrite_iters, + current_peak as f64 / (1024.0 * 1024.0), + max_rewrite_mem_bytes as f64 / (1024.0 * 1024.0), + ); + break; + } + } + let rewrite_peak_after = current_peak_memory_bytes(); + let rewrite_peak_memory_bytes = rewrite_peak_after.saturating_sub(rewrite_peak_before); + if breakdown { + eprintln!( + "[bench-breakdown] math-microbenchmark rewrites run_ruleset: {:?}", + t_rules_run.elapsed() + ); + print_callback_timings( + "math-microbenchmark rewrites", + &rewrite_callback_stats, + &rewrite_report, + ); + } + + let egraph = ::egraph(); let egraph = egraph.lock().unwrap(); let stats = MathMicrobenchmarkStats { elapsed: t_total.elapsed(), @@ -929,6 +1129,11 @@ pub fn run_and_collect_stats(breakdown: bool) -> MathMicrobenchmarkStats { .iter() .map(|table| (*table, egraph.get_size(table))) .collect(), + max_rewrite_mem_gib, + rewrite_peak_memory_bytes, + requested_rewrite_iters: rewrite_iters, + executed_rewrite_iters, + rewrite_stopped_early_due_to_memory_cap, }; if breakdown { eprintln!( @@ -943,3 +1148,241 @@ pub fn bench() { let breakdown = std::env::var_os("EGGPLANT_BENCH_BREAKDOWN").is_some(); let _ = run_and_collect_stats(breakdown); } + +#[cfg(feature = "rustsat-extract")] +fn build_extract_target() -> impl EgglogNode + EgglogTy + 'static { + let five = MVar::::new("five".to_owned()); + five.commit(); + let one_a = MConst::::new(1); + one_a.commit(); + let one_b = MConst::::new(1); + one_b.commit(); + let one_c = MConst::::new(1); + one_c.commit(); + let two_a = MConst::::new(2); + two_a.commit(); + let two_b = MConst::::new(2); + two_b.commit(); + + let sqrt_five_a = MSqrt::::new(&five); + sqrt_five_a.commit(); + let add_1_sqrt = MAdd::::new(&one_a, &sqrt_five_a); + add_1_sqrt.commit(); + let div_add = MDiv::::new(&add_1_sqrt, &two_a); + div_add.commit(); + + let sqrt_five_b = MSqrt::::new(&five); + sqrt_five_b.commit(); + let sub_1_sqrt = MSub::::new(&one_b, &sqrt_five_b); + sub_1_sqrt.commit(); + let div_sub = MDiv::::new(&sub_1_sqrt, &two_b); + div_sub.commit(); + + let denom = MSub::::new(&div_add, &div_sub); + denom.commit(); + let root = MDiv::::new(&one_c, &denom); + root.commit(); + root +} + +#[cfg(feature = "rustsat-extract")] +fn benchmark_extract_backend( + target: &N, + method: &'static str, + rewrite_peak_memory_bytes: u64, + backend: ExtractBackend, +) -> MathExtractComparisonRow +where + N: EgglogNode + EgglogTy + 'static, +{ + let extract_peak_before = current_peak_memory_bytes(); + let started = Instant::now(); + let (rendered, _cost) = MyTxMath::extract_node_to_string_with_backend(target, backend) + .expect("math microbench extraction should succeed"); + let svg_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("target") + .join("math_microbench_extract_svgs"); + fs::create_dir_all(&svg_dir).expect("svg output directory should be creatable"); + let svg_path = svg_dir.join(format!("{method}.svg")); + let _ = MyTxMath::extract_node_to_svg_with_backend( + target, + match method { + "default" => ExtractBackend::cost_model(TreeAdditiveCostModel::default()), + "eboost" => ExtractBackend::::eboost_heuristic( + EBoostExtractConfig::default(), + ), + "layered" => ExtractBackend::::eboost_layered( + EBoostLayeredConfig::default(), + ), + "rustsat" => { + ExtractBackend::::rustsat(RustsatExtractConfig::default()) + } + other => panic!("unsupported extract method `{other}`"), + }, + &svg_path, + ) + .expect("svg rendering should succeed for math microbench extract comparison"); + let extract_peak_after = current_peak_memory_bytes(); + MathExtractComparisonRow { + method, + requested_rewrite_iters: 0, + executed_rewrite_iters: 0, + max_rewrite_mem_gib: 0, + run_ruleset_note: String::new(), + rewrite_peak_memory_bytes, + extract_peak_memory_bytes: extract_peak_after.saturating_sub(extract_peak_before), + elapsed: started.elapsed(), + rendered, + svg_path: svg_path.display().to_string(), + } +} + +#[cfg(feature = "rustsat-extract")] +pub fn run_extract_comparison_with_iters_and_mem_cap( + rewrite_iters: usize, + max_rewrite_mem_gib: u64, +) -> Vec { + let stats = run_and_collect_stats_iters_with_mem_cap(false, rewrite_iters, max_rewrite_mem_gib); + let target = build_extract_target(); + + let mut rows = Vec::new(); + + let mut default_row = benchmark_extract_backend( + &target, + "default", + stats.rewrite_peak_memory_bytes, + ExtractBackend::cost_model(TreeAdditiveCostModel::default()), + ); + default_row.requested_rewrite_iters = stats.requested_rewrite_iters; + default_row.executed_rewrite_iters = stats.executed_rewrite_iters; + default_row.max_rewrite_mem_gib = stats.max_rewrite_mem_gib; + default_row.run_ruleset_note = if stats.rewrite_stopped_early_due_to_memory_cap { + format!( + "stopped early at {} / {} iterations because peak memory exceeded {} GiB", + stats.executed_rewrite_iters, stats.requested_rewrite_iters, stats.max_rewrite_mem_gib + ) + } else { + "completed requested iterations".to_string() + }; + rows.push(default_row); + + let mut eboost_row = benchmark_extract_backend( + &target, + "eboost", + stats.rewrite_peak_memory_bytes, + ExtractBackend::::eboost_heuristic(EBoostExtractConfig::default()), + ); + eboost_row.requested_rewrite_iters = stats.requested_rewrite_iters; + eboost_row.executed_rewrite_iters = stats.executed_rewrite_iters; + eboost_row.max_rewrite_mem_gib = stats.max_rewrite_mem_gib; + eboost_row.run_ruleset_note = if stats.rewrite_stopped_early_due_to_memory_cap { + format!( + "stopped early at {} / {} iterations because peak memory exceeded {} GiB", + stats.executed_rewrite_iters, stats.requested_rewrite_iters, stats.max_rewrite_mem_gib + ) + } else { + "completed requested iterations".to_string() + }; + rows.push(eboost_row); + + let mut layered_row = benchmark_extract_backend( + &target, + "layered", + stats.rewrite_peak_memory_bytes, + ExtractBackend::::eboost_layered(EBoostLayeredConfig::default()), + ); + layered_row.requested_rewrite_iters = stats.requested_rewrite_iters; + layered_row.executed_rewrite_iters = stats.executed_rewrite_iters; + layered_row.max_rewrite_mem_gib = stats.max_rewrite_mem_gib; + layered_row.run_ruleset_note = if stats.rewrite_stopped_early_due_to_memory_cap { + format!( + "stopped early at {} / {} iterations because peak memory exceeded {} GiB", + stats.executed_rewrite_iters, stats.requested_rewrite_iters, stats.max_rewrite_mem_gib + ) + } else { + "completed requested iterations".to_string() + }; + rows.push(layered_row); + + let mut rustsat_row = benchmark_extract_backend( + &target, + "rustsat", + stats.rewrite_peak_memory_bytes, + ExtractBackend::::rustsat(RustsatExtractConfig::default()), + ); + rustsat_row.requested_rewrite_iters = stats.requested_rewrite_iters; + rustsat_row.executed_rewrite_iters = stats.executed_rewrite_iters; + rustsat_row.max_rewrite_mem_gib = stats.max_rewrite_mem_gib; + rustsat_row.run_ruleset_note = if stats.rewrite_stopped_early_due_to_memory_cap { + format!( + "stopped early at {} / {} iterations because peak memory exceeded {} GiB", + stats.executed_rewrite_iters, stats.requested_rewrite_iters, stats.max_rewrite_mem_gib + ) + } else { + "completed requested iterations".to_string() + }; + rows.push(rustsat_row); + + rows +} + +#[cfg(feature = "rustsat-extract")] +pub fn run_extract_comparison_with_iters(rewrite_iters: usize) -> Vec { + run_extract_comparison_with_iters_and_mem_cap(rewrite_iters, DEFAULT_RUN_RULESET_MEMORY_CAP_GIB) +} + +#[cfg(feature = "rustsat-extract")] +pub fn run_extract_comparison() -> Vec { + run_extract_comparison_with_iters(11) +} + +pub fn run_div_add_rewrite_smoke(rewrite_iters: usize, cost_model: CM) -> String +where + CM: eggplant::egglog::extract::CostModel + 'static, +{ + MyTxMath::reset_for_bench(); + + let one = MConst::::new(1); + let x = MVar::::new("x".to_owned()); + let two = MConst::::new(2); + let add = MAdd::::new(&one, &x); + let root = MDiv::::new(&add, &two); + root.commit(); + + let rs = MyTxMath::new_ruleset("math_microbenchmark_div_add_smoke"); + { + MyTxMath::add_rule( + "div_add_distrib_smoke", + rs, + || { + let a = Math::query_leaf(); + let b = Math::query_leaf(); + let c = Math::query_leaf(); + let add = MAdd::query(&a, &b); + let div = MDiv::query(&add, &c); + #[eggplant::pat_vars] + struct Pat { + a: Math, + b: Math, + c: Math, + div: MDiv, + } + Pat::new(a, b, c, div) + }, + |ctx, pat| { + let a_div_c = ctx.insert_m_div(pat.a, pat.c); + let b_div_c = ctx.insert_m_div(pat.b, pat.c); + let rhs = ctx.insert_m_add(a_div_c, b_div_c); + ctx.union(pat.div, rhs); + }, + ); + }; + + for _ in 0..rewrite_iters { + MyTxMath::run_ruleset(rs, RunConfig::Once); + } + + let (rendered, _) = MyTxMath::extract_node_to_string_with_cost_model(&root, cost_model) + .expect("smoke extract should succeed"); + rendered +} diff --git a/benches/runners/eggplant_rewrite/math_microbenchmark_no_calculus.rs b/benches/runners/eggplant_rewrite/math_microbenchmark_no_calculus.rs new file mode 100644 index 0000000..0705395 --- /dev/null +++ b/benches/runners/eggplant_rewrite/math_microbenchmark_no_calculus.rs @@ -0,0 +1,1672 @@ +use egglog_reports::RunReport; +use eggplant::prelude::*; +use eggplant::tx_rx_vt_pr; +use eggplant::wrap::NonPatRecSgl; +use serde::{Deserialize, Serialize}; +use std::collections::BTreeMap; +use std::sync::{Arc, Mutex}; +use std::time::{Duration, Instant}; + +#[cfg(feature = "rustsat-extract")] +use eggplant::egglog::extract::TreeAdditiveCostModel; +#[cfg(feature = "rustsat-extract")] +use eggplant::wrap::EgglogTy; +#[cfg(feature = "rustsat-extract")] +use std::fs; +#[cfg(feature = "rustsat-extract")] +use std::path::PathBuf; + +#[eggplant::dsl] +enum MathNoCalc { + #[typst("{a} + {b}")] + #[precedence(50)] + #[cost(1)] + MAdd { a: MathNoCalc, b: MathNoCalc }, + #[typst("{a} - {b}")] + #[precedence(50)] + #[cost(1)] + MSub { a: MathNoCalc, b: MathNoCalc }, + #[typst("{a} * {b}")] + #[precedence(60)] + #[cost(3)] + MMul { a: MathNoCalc, b: MathNoCalc }, + #[typst("frac({a}, {b}) ")] + #[precedence(60)] + #[cost(10)] + MDiv { a: MathNoCalc, b: MathNoCalc }, + #[typst("{a}^{b}")] + #[precedence(80)] + #[cost(25)] + MPow { a: MathNoCalc, b: MathNoCalc }, + #[typst("ln {a}")] + #[precedence(90)] + #[cost(18)] + MLn { a: MathNoCalc }, + #[typst("sqrt({a})")] + #[precedence(90)] + #[cost(16)] + MSqrt { a: MathNoCalc }, + + #[typst("sin({a})")] + #[precedence(90)] + #[cost(18)] + MSin { a: MathNoCalc }, + #[typst("cos({a})")] + #[precedence(90)] + #[cost(18)] + MCos { a: MathNoCalc }, + + #[typst("{n}")] + #[precedence(100)] + #[cost(1)] + MConst { n: i64 }, + #[typst("{name}")] + #[precedence(100)] + #[cost(1)] + MVar { name: String }, +} + +tx_rx_vt_pr!(MyTxMathNoCalc, MyPatRecMathNoCalcNoCalc); + +#[derive(Default, Clone, Copy)] +struct CallbackTiming { + total: Duration, + calls: usize, +} + +type SharedCallbackTimings = Arc>>; + +pub struct MathMicrobenchmarkStats { + pub elapsed: Duration, + pub total_num_tuples: usize, + pub table_sizes: Vec<(&'static str, usize)>, + pub max_rewrite_mem_gib: u64, + pub rewrite_peak_memory_bytes: u64, + pub requested_rewrite_iters: usize, + pub executed_rewrite_iters: usize, + pub rewrite_stopped_early_due_to_memory_cap: bool, +} + +pub struct MathExtractComparisonRow { + pub method: &'static str, + pub requested_rewrite_iters: usize, + pub executed_rewrite_iters: usize, + pub max_rewrite_mem_gib: u64, + pub run_ruleset_note: String, + pub rewrite_peak_memory_bytes: u64, + pub extract_peak_memory_bytes: Option, + pub cost: Option, + pub elapsed: Option, + pub rendered: String, + pub svg_path: String, + pub timed_out: bool, +} + +#[derive(Debug, Clone)] +pub enum ProgressEvent { + RewriteIterationComplete { + current: usize, + total: usize, + tuple_count: usize, + peak_memory_bytes: u64, + }, + RewriteStoppedByMemoryCap { + current: usize, + total: usize, + peak_memory_bytes: u64, + cap_bytes: u64, + }, + ExtractPhaseStart { + method: &'static str, + current: usize, + total: usize, + }, + ExtractPhaseComplete { + method: &'static str, + current: usize, + total: usize, + elapsed_ms: f64, + peak_memory_bytes: u64, + }, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ExtractTimelineMetric { + pub method: String, + pub cost: Option, + pub elapsed_ms: Option, + pub peak_memory_bytes: Option, + pub svg_path: String, + pub timed_out: bool, +} + +#[derive(Debug, Clone, Serialize)] +pub struct RewriteTimelinePoint { + pub iteration: usize, + pub tuple_count: usize, + pub rewrite_elapsed_ms: f64, + pub rewrite_peak_memory_bytes: u64, + pub rule_matches: BTreeMap, + pub extracts: Vec, +} + +#[derive(Debug, Clone, Serialize)] +pub struct ExtractTimelineReport { + pub version_nickname: Option, + pub selected_extractors: Vec, + pub max_extract_time_secs: Option, + pub requested_rewrite_iters: usize, + pub executed_rewrite_iters: usize, + pub max_rewrite_mem_gib: u64, + pub stopped_early_due_to_memory_cap: bool, + pub points: Vec, +} + +#[cfg(feature = "rustsat-extract")] +const ALL_EXTRACT_METHODS: &[&str] = &["default", "eboost", "layered", "rustsat"]; + +const DEFAULT_RUN_RULESET_MEMORY_CAP_GIB: u64 = 20; + +const MATH_TABLES: &[&str] = &[ + "MAdd", "MSub", "MMul", "MDiv", "MPow", "MLn", "MSqrt", "MSin", "MCos", "MConst", "MVar", +]; + +fn record_callback_timing( + stats: &Option, + rule_name: &'static str, + elapsed: Duration, +) { + let Some(stats) = stats else { + return; + }; + let mut stats = stats.lock().unwrap(); + let entry = stats.entry(rule_name).or_default(); + entry.total += elapsed; + entry.calls += 1; +} + +fn print_callback_timings(label: &str, stats: &Option, report: &RunReport) { + let Some(stats) = stats else { + return; + }; + let stats = stats.lock().unwrap(); + let mut rows = stats + .iter() + .map(|(rule, timing)| (*rule, *timing)) + .collect::>(); + rows.sort_by_key(|(_, timing)| std::cmp::Reverse(timing.total)); + let callback_total = rows + .iter() + .fold(Duration::ZERO, |acc, (_, t)| acc + t.total); + eprintln!( + "[bench-breakdown] {label} callback total: {:?}", + callback_total + ); + for (rule, timing) in rows { + let matches = report + .num_matches_per_rule + .get(format!("@{rule}").as_str()) + .copied() + .unwrap_or(0); + let avg = if timing.calls == 0 { + Duration::ZERO + } else { + Duration::from_secs_f64(timing.total.as_secs_f64() / timing.calls as f64) + }; + eprintln!( + "[bench-breakdown] {label} callback {rule}: total={:?}, calls={}, avg={:?}, matches={}", + timing.total, timing.calls, avg, matches + ); + } +} + +fn register_rewrite_rules( + rs: RuleSetId, + sub_self: &'static str, + mul_distrib: &'static str, + add_factor: &'static str, + mul_pow_combine: &'static str, +) { + MyTxMathNoCalc::add_rule( + "add_comm", + rs, + || { + let a = MathNoCalc::query_leaf(); + let b = MathNoCalc::query_leaf(); + let add = MAdd::query(&a, &b); + #[eggplant::pat_vars] + struct Pat { + a: MathNoCalc, + b: MathNoCalc, + add: MAdd, + } + Pat::new(a, b, add) + }, + |ctx, pat| { + let rhs = ctx.insert_m_add(pat.b, pat.a); + ctx.union(pat.add, rhs); + }, + ); + MyTxMathNoCalc::add_rule( + "mul_comm", + rs, + || { + let a = MathNoCalc::query_leaf(); + let b = MathNoCalc::query_leaf(); + let mul = MMul::query(&a, &b); + #[eggplant::pat_vars] + struct Pat { + a: MathNoCalc, + b: MathNoCalc, + mul: MMul, + } + Pat::new(a, b, mul) + }, + |ctx, pat| { + let rhs = ctx.insert_m_mul(pat.b, pat.a); + ctx.union(pat.mul, rhs); + }, + ); + MyTxMathNoCalc::add_rule( + "add_assoc", + rs, + || { + let a = MathNoCalc::query_leaf(); + let b = MathNoCalc::query_leaf(); + let c = MathNoCalc::query_leaf(); + let add_inner = MAdd::query(&b, &c); + let add_outer = MAdd::query(&a, &add_inner); + #[eggplant::pat_vars] + struct Pat { + a: MathNoCalc, + b: MathNoCalc, + c: MathNoCalc, + add_outer: MAdd, + } + Pat::new(a, b, c, add_outer) + }, + |ctx, pat| { + let ab = ctx.insert_m_add(pat.a, pat.b); + let rhs = ctx.insert_m_add(ab, pat.c); + ctx.union(pat.add_outer, rhs); + }, + ); + MyTxMathNoCalc::add_rule( + "mul_assoc", + rs, + || { + let a = MathNoCalc::query_leaf(); + let b = MathNoCalc::query_leaf(); + let c = MathNoCalc::query_leaf(); + let mul_inner = MMul::query(&b, &c); + let mul_outer = MMul::query(&a, &mul_inner); + #[eggplant::pat_vars] + struct Pat { + a: MathNoCalc, + b: MathNoCalc, + c: MathNoCalc, + mul_outer: MMul, + } + Pat::new(a, b, c, mul_outer) + }, + |ctx, pat| { + let ab = ctx.insert_m_mul(pat.a, pat.b); + let rhs = ctx.insert_m_mul(ab, pat.c); + ctx.union(pat.mul_outer, rhs); + }, + ); + MyTxMathNoCalc::add_rule( + "sub_to_add_neg", + rs, + || { + let a = MathNoCalc::query_leaf(); + let b = MathNoCalc::query_leaf(); + let sub = MSub::query(&a, &b); + #[eggplant::pat_vars] + struct Pat { + a: MathNoCalc, + b: MathNoCalc, + sub: MSub, + } + Pat::new(a, b, sub) + }, + |ctx, pat| { + let neg1 = ctx.insert_m_const(-1); + let neg_b = ctx.insert_m_mul(neg1, pat.b); + let rhs = ctx.insert_m_add(pat.a, neg_b); + ctx.union(pat.sub, rhs); + }, + ); + MyTxMathNoCalc::add_rule( + "add_neg_self_zero", + rs, + || { + let a = MathNoCalc::query_leaf(); + let b = MathNoCalc::query_leaf(); + let neg_one = MConst::query(); + let neg_b = MMul::query(&neg_one, &b); + let add = MAdd::query(&a, &neg_b); + let is_neg_one = neg_one.handle_n().eq(&-1_i64); + let same_term = a.handle().eq(&b.handle()); + #[eggplant::pat_vars] + struct Pat { + a: MathNoCalc, + b: MathNoCalc, + neg_one: MConst, + add: MAdd, + } + Pat::new(a, b, neg_one, add) + .assert(is_neg_one) + .assert(same_term) + }, + |ctx, pat| { + let z = ctx.insert_m_const(0); + ctx.union(pat.add, z); + }, + ); + MyTxMathNoCalc::add_rule( + "add_zero", + rs, + || { + let a = MathNoCalc::query_leaf(); + let z = MConst::query(); + let add = MAdd::query(&a, &z); + let is_zero = z.handle_n().eq(&0_i64); + #[eggplant::pat_vars] + struct Pat { + a: MathNoCalc, + z: MConst, + add: MAdd, + } + Pat::new(a, z, add).assert(is_zero) + }, + |ctx, pat| { + ctx.union(pat.add, pat.a); + }, + ); + MyTxMathNoCalc::add_rule( + "mul_zero", + rs, + || { + let a = MathNoCalc::query_leaf(); + let z = MConst::query(); + let mul = MMul::query(&a, &z); + let is_zero = z.handle_n().eq(&0_i64); + #[eggplant::pat_vars] + struct Pat { + a: MathNoCalc, + z: MConst, + mul: MMul, + } + Pat::new(a, z, mul).assert(is_zero) + }, + |ctx, pat| { + ctx.union(pat.mul, pat.z); + }, + ); + MyTxMathNoCalc::add_rule( + "mul_one", + rs, + || { + let a = MathNoCalc::query_leaf(); + let o = MConst::query(); + let mul = MMul::query(&a, &o); + let is_one = o.handle_n().eq(&1_i64); + #[eggplant::pat_vars] + struct Pat { + a: MathNoCalc, + o: MConst, + mul: MMul, + } + Pat::new(a, o, mul).assert(is_one) + }, + |ctx, pat| { + ctx.union(pat.mul, pat.a); + }, + ); + MyTxMathNoCalc::add_rule( + sub_self, + rs, + || { + let a = MathNoCalc::query_leaf(); + let b = MathNoCalc::query_leaf(); + let sub = MSub::query(&a, &b); + let same_terms = a.handle().eq(&b.handle()); + #[eggplant::pat_vars] + struct Pat { + a: MathNoCalc, + sub: MSub, + } + Pat::new(a, sub).assert(same_terms) + }, + |ctx, pat| { + let z = ctx.insert_m_const(0); + ctx.union(pat.sub, z); + }, + ); + MyTxMathNoCalc::add_rule( + mul_distrib, + rs, + || { + let a = MathNoCalc::query_leaf(); + let b = MathNoCalc::query_leaf(); + let c = MathNoCalc::query_leaf(); + let add = MAdd::query(&b, &c); + let mul = MMul::query(&a, &add); + #[eggplant::pat_vars] + struct Pat { + a: MathNoCalc, + b: MathNoCalc, + c: MathNoCalc, + mul: MMul, + } + Pat::new(a, b, c, mul) + }, + |ctx, pat| { + let ab = ctx.insert_m_mul(pat.a, pat.b); + let ac = ctx.insert_m_mul(pat.a, pat.c); + let rhs = ctx.insert_m_add(ab, ac); + ctx.union(pat.mul, rhs); + }, + ); + MyTxMathNoCalc::add_rule( + add_factor, + rs, + || { + let a = MathNoCalc::query_leaf(); + let b = MathNoCalc::query_leaf(); + let c = MathNoCalc::query_leaf(); + let mul1 = MMul::query(&a, &b); + let mul2 = MMul::query(&a, &c); + let add = MAdd::query(&mul1, &mul2); + #[eggplant::pat_vars] + struct Pat { + a: MathNoCalc, + b: MathNoCalc, + c: MathNoCalc, + add: MAdd, + } + Pat::new(a, b, c, add) + }, + |ctx, pat| { + let bc = ctx.insert_m_add(pat.b, pat.c); + let rhs = ctx.insert_m_mul(pat.a, bc); + ctx.union(pat.add, rhs); + }, + ); + MyTxMathNoCalc::add_rule( + mul_pow_combine, + rs, + || { + let a = MathNoCalc::query_leaf(); + let b = MathNoCalc::query_leaf(); + let c = MathNoCalc::query_leaf(); + let p1 = MPow::query(&a, &b); + let p2 = MPow::query(&a, &c); + let mul = MMul::query(&p1, &p2); + #[eggplant::pat_vars] + struct Pat { + a: MathNoCalc, + b: MathNoCalc, + c: MathNoCalc, + mul: MMul, + } + Pat::new(a, b, c, mul) + }, + |ctx, pat| { + let bc = ctx.insert_m_add(pat.b, pat.c); + let rhs = ctx.insert_m_pow(pat.a, bc); + ctx.union(pat.mul, rhs); + }, + ); + MyTxMathNoCalc::add_rule( + "div_add_distrib", + rs, + || { + let a = MathNoCalc::query_leaf(); + let b = MathNoCalc::query_leaf(); + let c = MathNoCalc::query_leaf(); + let add = MAdd::query(&a, &b); + let div = MDiv::query(&add, &c); + #[eggplant::pat_vars] + struct Pat { + a: MathNoCalc, + b: MathNoCalc, + c: MathNoCalc, + div: MDiv, + } + Pat::new(a, b, c, div) + }, + |ctx, pat| { + let a_div_c = ctx.insert_m_div(pat.a, pat.c); + let b_div_c = ctx.insert_m_div(pat.b, pat.c); + let rhs = ctx.insert_m_add(a_div_c, b_div_c); + ctx.union(pat.div, rhs); + }, + ); + MyTxMathNoCalc::add_rule( + "div_sub_distrib", + rs, + || { + let a = MathNoCalc::query_leaf(); + let b = MathNoCalc::query_leaf(); + let c = MathNoCalc::query_leaf(); + let sub = MSub::query(&a, &b); + let div = MDiv::query(&sub, &c); + #[eggplant::pat_vars] + struct Pat { + a: MathNoCalc, + b: MathNoCalc, + c: MathNoCalc, + div: MDiv, + } + Pat::new(a, b, c, div) + }, + |ctx, pat| { + let a_div_c = ctx.insert_m_div(pat.a, pat.c); + let b_div_c = ctx.insert_m_div(pat.b, pat.c); + let rhs = ctx.insert_m_sub(a_div_c, b_div_c); + ctx.union(pat.div, rhs); + }, + ); + MyTxMathNoCalc::add_rule( + "add_frac_cross", + rs, + || { + let a = MathNoCalc::query_leaf(); + let b = MathNoCalc::query_leaf(); + let c = MathNoCalc::query_leaf(); + let d = MathNoCalc::query_leaf(); + let lhs = MDiv::query(&a, &b); + let rhs = MDiv::query(&c, &d); + let add = MAdd::query(&lhs, &rhs); + #[eggplant::pat_vars] + struct Pat { + a: MathNoCalc, + b: MathNoCalc, + c: MathNoCalc, + d: MathNoCalc, + add: MAdd, + } + Pat::new(a, b, c, d, add) + }, + |ctx, pat| { + let ad = ctx.insert_m_mul(pat.a, pat.d); + let cb = ctx.insert_m_mul(pat.c, pat.b); + let num = ctx.insert_m_add(ad, cb); + let den = ctx.insert_m_mul(pat.b, pat.d); + let rhs = ctx.insert_m_div(num, den); + ctx.union(pat.add, rhs); + }, + ); + MyTxMathNoCalc::add_rule( + "sub_frac_cross", + rs, + || { + let a = MathNoCalc::query_leaf(); + let b = MathNoCalc::query_leaf(); + let c = MathNoCalc::query_leaf(); + let d = MathNoCalc::query_leaf(); + let lhs = MDiv::query(&a, &b); + let rhs = MDiv::query(&c, &d); + let sub = MSub::query(&lhs, &rhs); + #[eggplant::pat_vars] + struct Pat { + a: MathNoCalc, + b: MathNoCalc, + c: MathNoCalc, + d: MathNoCalc, + sub: MSub, + } + Pat::new(a, b, c, d, sub) + }, + |ctx, pat| { + let ad = ctx.insert_m_mul(pat.a, pat.d); + let cb = ctx.insert_m_mul(pat.c, pat.b); + let num = ctx.insert_m_sub(ad, cb); + let den = ctx.insert_m_mul(pat.b, pat.d); + let rhs = ctx.insert_m_div(num, den); + ctx.union(pat.sub, rhs); + }, + ); + MyTxMathNoCalc::add_rule( + "pow_one", + rs, + || { + let x = MathNoCalc::query_leaf(); + let o = MConst::query(); + let pow = MPow::query(&x, &o); + let is_one = o.handle_n().eq(&1_i64); + #[eggplant::pat_vars] + struct Pat { + x: MathNoCalc, + o: MConst, + pow: MPow, + } + Pat::new(x, o, pow).assert(is_one) + }, + |ctx, pat| { + ctx.union(pat.pow, pat.x); + }, + ); + MyTxMathNoCalc::add_rule( + "pow_two", + rs, + || { + let x = MathNoCalc::query_leaf(); + let t = MConst::query(); + let pow = MPow::query(&x, &t); + let is_two = t.handle_n().eq(&2_i64); + #[eggplant::pat_vars] + struct Pat { + x: MathNoCalc, + t: MConst, + pow: MPow, + } + Pat::new(x, t, pow).assert(is_two) + }, + |ctx, pat| { + let rhs = ctx.insert_m_mul(pat.x, pat.x); + ctx.union(pat.pow, rhs); + }, + ); +} + +pub fn run_and_collect_stats(breakdown: bool) -> MathMicrobenchmarkStats { + let t_total = Instant::now(); + let seed_callback_stats = breakdown.then(|| Arc::new(Mutex::new(BTreeMap::new()))); + let rewrite_callback_stats = breakdown.then(|| Arc::new(Mutex::new(BTreeMap::new()))); + + let t = Instant::now(); + MyTxMathNoCalc::reset_for_bench(); + if breakdown { + eprintln!( + "[bench-breakdown] math-microbenchmark reset_for_bench: {:?}", + t.elapsed() + ); + } + + // Seed ground terms (ports `tests/math-microbenchmark.egg`). + let t_seed_setup = Instant::now(); + let seed = MyTxMathNoCalc::new_ruleset("math_microbenchmark_no_calculus_seed"); + MyTxMathNoCalc::add_rule( + "math_microbenchmark_no_calculus_seed", + seed, + || { + #[eggplant::pat_vars_catch] + struct Unit {} + }, + |ctx, _pat| { + let _x = ctx.insert_m_var("x".to_owned()); + let _y = ctx.insert_m_var("y".to_owned()); + let five = ctx.insert_m_var("five".to_owned()); + + // // (Integral (Ln (Var "x")) (Var "x")) + // let ln_x = ctx.insert_m_ln(x.clone()); + // ctx.insert_m_integral(ln_x, x.clone()); + + // // (Integral (Add (Var "x") (Cos (Var "x"))) (Var "x")) + // let cos_x = ctx.insert_m_cos(x.clone()); + // let add_x_cos_x = ctx.insert_m_add(x.clone(), cos_x); + // ctx.insert_m_integral(add_x_cos_x, x.clone()); + + // // (Integral (Mul (Cos (Var "x")) (Var "x")) (Var "x")) + // let cos_x = ctx.insert_m_cos(x.clone()); + // let mul_cos_x_x = ctx.insert_m_mul(cos_x, x.clone()); + // ctx.insert_m_integral(mul_cos_x_x, x.clone()); + + // // (Diff (Var "x") (Add (Const 1) (Mul (Const 2) (Var "x")))) + // let c1 = ctx.insert_m_const(1); + // let c2 = ctx.insert_m_const(2); + // let mul_2_x = ctx.insert_m_mul(c2, x.clone()); + // let add_1_2x = ctx.insert_m_add(c1, mul_2_x); + // ctx.insert_m_diff(x.clone(), add_1_2x); + + // // (Diff (Var "x") (Sub (Pow (Var "x") (Const 3)) + // // (Mul (Const 7) (Pow (Var "x") (Const 2))))) + // let c3 = ctx.insert_m_const(3); + // let c7 = ctx.insert_m_const(7); + // let pow_x_3 = ctx.insert_m_pow(x.clone(), c3); + // let pow_x_2 = ctx.insert_m_pow(x.clone(), ctx.insert_m_const(2)); + // let mul_7_pow = ctx.insert_m_mul(c7, pow_x_2); + // let sub_pow = ctx.insert_m_sub(pow_x_3, mul_7_pow); + // ctx.insert_m_diff(x.clone(), sub_pow); + + // // (Add (Mul (Var "y") (Add (Var "x") (Var "y"))) + // // (Sub (Add (Var "x") (Const 2)) (Add (Var "x") (Var "x")))) + // let add_x_y = ctx.insert_m_add(x.clone(), y.clone()); + // let mul_y_add = ctx.insert_m_mul(y.clone(), add_x_y); + // let add_x_2 = ctx.insert_m_add(x.clone(), ctx.insert_m_const(2)); + // let add_x_x = ctx.insert_m_add(x.clone(), x.clone()); + // let sub_add = ctx.insert_m_sub(add_x_2, add_x_x); + // ctx.insert_m_add(mul_y_add, sub_add); + + // // (Div (Const 1) (Sub (Div (Add (Const 1) (Sqrt (Var "five"))) (Const 2)) + // // (Div (Sub (Const 1) (Sqrt (Var "five"))) (Const 2)))) + let c1 = ctx.insert_m_const(1); + let c2 = ctx.insert_m_const(2); + let sqrt_five = ctx.insert_m_sqrt(five.clone()); + let add_1_sqrt = ctx.insert_m_add(c1, sqrt_five.clone()); + let div_add = ctx.insert_m_div(add_1_sqrt, c2); + let sub_1_sqrt = ctx.insert_m_sub(ctx.insert_m_const(1), sqrt_five); + let div_sub = ctx.insert_m_div(sub_1_sqrt, ctx.insert_m_const(2)); + let denom = ctx.insert_m_sub(div_add, div_sub); + ctx.insert_m_div(ctx.insert_m_const(1), denom); + }, + ); + if breakdown { + eprintln!( + "[bench-breakdown] math-microbenchmark seed add_rule: {:?}", + t_seed_setup.elapsed() + ); + } + + let t_seed_run = Instant::now(); + let seed_report = MyTxMathNoCalc::run_ruleset(seed, RunConfig::Once); + if breakdown { + eprintln!( + "[bench-breakdown] math-microbenchmark seed run_ruleset: {:?}", + t_seed_run.elapsed() + ); + print_callback_timings( + "math-microbenchmark seed", + &seed_callback_stats, + &seed_report, + ); + } + + // Rewrite rules (ports `tests/math-microbenchmark.egg` rewrites). + let t_rules_setup = Instant::now(); + let rs = MyTxMathNoCalc::new_ruleset("math_microbenchmark_no_calculus_rules"); + register_rewrite_rules( + rs, + "sub_self_zero", + "mul_distrib", + "add_factor", + "mul_pow_combine", + ); + + if breakdown { + eprintln!( + "[bench-breakdown] math-microbenchmark rewrites add_rule: {:?}", + t_rules_setup.elapsed() + ); + } + + let t_rules_run = Instant::now(); + let rewrite_report = MyTxMathNoCalc::run_ruleset(rs, RunConfig::Times(11)); + if breakdown { + eprintln!( + "[bench-breakdown] math-microbenchmark rewrites run_ruleset: {:?}", + t_rules_run.elapsed() + ); + print_callback_timings( + "math-microbenchmark rewrites", + &rewrite_callback_stats, + &rewrite_report, + ); + } + + let egraph = ::egraph(); + let egraph = egraph.lock().unwrap(); + let stats = MathMicrobenchmarkStats { + elapsed: t_total.elapsed(), + total_num_tuples: egraph.num_tuples(), + table_sizes: MATH_TABLES + .iter() + .map(|table| (*table, egraph.get_size(table))) + .collect(), + max_rewrite_mem_gib: DEFAULT_RUN_RULESET_MEMORY_CAP_GIB, + rewrite_peak_memory_bytes: 0, + requested_rewrite_iters: 11, + executed_rewrite_iters: 11, + rewrite_stopped_early_due_to_memory_cap: false, + }; + if breakdown { + eprintln!( + "[bench-breakdown] math-microbenchmark total: {:?}", + t_total.elapsed() + ); + } + stats +} + +pub fn run_and_collect_stats_iters( + breakdown: bool, + rewrite_iters: usize, +) -> MathMicrobenchmarkStats { + run_and_collect_stats_iters_with_mem_cap( + breakdown, + rewrite_iters, + DEFAULT_RUN_RULESET_MEMORY_CAP_GIB, + ) +} + +pub fn run_and_collect_stats_iters_with_mem_cap( + breakdown: bool, + rewrite_iters: usize, + max_rewrite_mem_gib: u64, +) -> MathMicrobenchmarkStats { + run_and_collect_stats_iters_with_mem_cap_and_progress( + breakdown, + rewrite_iters, + max_rewrite_mem_gib, + |_| {}, + ) +} + +pub fn run_and_collect_stats_iters_with_mem_cap_and_progress( + breakdown: bool, + rewrite_iters: usize, + max_rewrite_mem_gib: u64, + mut on_progress: F, +) -> MathMicrobenchmarkStats +where + F: FnMut(ProgressEvent), +{ + let t_total = Instant::now(); + let seed_callback_stats = breakdown.then(|| Arc::new(Mutex::new(BTreeMap::new()))); + let rewrite_callback_stats = breakdown.then(|| Arc::new(Mutex::new(BTreeMap::new()))); + let max_rewrite_mem_bytes = gib_to_bytes(max_rewrite_mem_gib); + + let t = Instant::now(); + MyTxMathNoCalc::reset_for_bench(); + if breakdown { + eprintln!( + "[bench-breakdown] math-microbenchmark reset_for_bench: {:?}", + t.elapsed() + ); + } + + let t_seed_setup = Instant::now(); + let seed = MyTxMathNoCalc::new_ruleset("math_microbenchmark_no_calculus_seed_iters"); + MyTxMathNoCalc::add_rule( + "math_microbenchmark_no_calculus_seed_iters", + seed, + || { + #[eggplant::pat_vars_catch] + struct Unit {} + }, + |ctx, _pat| { + let x = ctx.insert_m_var("x".to_owned()); + let y = ctx.insert_m_var("y".to_owned()); + let five = ctx.insert_m_var("five".to_owned()); + + let add_x_y = ctx.insert_m_add(x.clone(), y.clone()); + let mul_y_add = ctx.insert_m_mul(y.clone(), add_x_y); + let add_x_2 = ctx.insert_m_add(x.clone(), ctx.insert_m_const(2)); + let add_x_x = ctx.insert_m_add(x.clone(), x.clone()); + let sub_add = ctx.insert_m_sub(add_x_2, add_x_x); + ctx.insert_m_add(mul_y_add, sub_add); + + let c1 = ctx.insert_m_const(1); + let c2 = ctx.insert_m_const(2); + let sqrt_five = ctx.insert_m_sqrt(five.clone()); + let add_1_sqrt = ctx.insert_m_add(c1, sqrt_five.clone()); + let div_add = ctx.insert_m_div(add_1_sqrt, c2); + let sub_1_sqrt = ctx.insert_m_sub(ctx.insert_m_const(1), sqrt_five); + let div_sub = ctx.insert_m_div(sub_1_sqrt, ctx.insert_m_const(2)); + let denom = ctx.insert_m_sub(div_add, div_sub); + ctx.insert_m_div(ctx.insert_m_const(1), denom); + }, + ); + if breakdown { + eprintln!( + "[bench-breakdown] math-microbenchmark seed add_rule: {:?}", + t_seed_setup.elapsed() + ); + } + + let t_seed_run = Instant::now(); + let seed_report = MyTxMathNoCalc::run_ruleset(seed, RunConfig::Once); + if breakdown { + eprintln!( + "[bench-breakdown] math-microbenchmark seed run_ruleset: {:?}", + t_seed_run.elapsed() + ); + print_callback_timings( + "math-microbenchmark seed", + &seed_callback_stats, + &seed_report, + ); + } + + let t_rules_setup = Instant::now(); + let rs = MyTxMathNoCalc::new_ruleset("math_microbenchmark_no_calculus_rules_iters"); + register_rewrite_rules( + rs, + "sub_self", + "distribute_mul", + "factor_mul", + "pow_mul_same_base", + ); + + if breakdown { + eprintln!( + "[bench-breakdown] math-microbenchmark rewrites add_rule: {:?}", + t_rules_setup.elapsed() + ); + } + + let t_rules_run = Instant::now(); + let rewrite_peak_before = current_peak_memory_bytes(); + let mut rewrite_report = RunReport::default(); + let mut executed_rewrite_iters = 0usize; + let mut rewrite_stopped_early_due_to_memory_cap = false; + for _ in 0..rewrite_iters { + let report = MyTxMathNoCalc::run_ruleset(rs, RunConfig::Once); + rewrite_report.union(report); + executed_rewrite_iters += 1; + let current_peak = current_peak_memory_bytes(); + let tuple_count = { + let egraph = ::egraph(); + let egraph = egraph.lock().unwrap(); + egraph.num_tuples() + }; + eprintln!( + "[math-microbenchmark] completed rewrite iteration {}/{}, tuples={}, peak_mem={:.2} MiB", + executed_rewrite_iters, + rewrite_iters, + tuple_count, + current_peak as f64 / (1024.0 * 1024.0), + ); + on_progress(ProgressEvent::RewriteIterationComplete { + current: executed_rewrite_iters, + total: rewrite_iters, + tuple_count, + peak_memory_bytes: current_peak, + }); + if current_peak > max_rewrite_mem_bytes { + rewrite_stopped_early_due_to_memory_cap = true; + eprintln!( + "[math-microbenchmark] stopping early after iteration {} because peak memory {:.2} MiB exceeded configured cap {:.2} MiB", + executed_rewrite_iters, + current_peak as f64 / (1024.0 * 1024.0), + max_rewrite_mem_bytes as f64 / (1024.0 * 1024.0), + ); + on_progress(ProgressEvent::RewriteStoppedByMemoryCap { + current: executed_rewrite_iters, + total: rewrite_iters, + peak_memory_bytes: current_peak, + cap_bytes: max_rewrite_mem_bytes, + }); + break; + } + } + let rewrite_peak_after = current_peak_memory_bytes(); + let rewrite_peak_memory_bytes = rewrite_peak_after.saturating_sub(rewrite_peak_before); + if breakdown { + eprintln!( + "[bench-breakdown] math-microbenchmark rewrites run_ruleset: {:?}", + t_rules_run.elapsed() + ); + print_callback_timings( + "math-microbenchmark rewrites", + &rewrite_callback_stats, + &rewrite_report, + ); + } + + let egraph = ::egraph(); + let egraph = egraph.lock().unwrap(); + let stats = MathMicrobenchmarkStats { + elapsed: t_total.elapsed(), + total_num_tuples: egraph.num_tuples(), + table_sizes: MATH_TABLES + .iter() + .map(|table| (*table, egraph.get_size(table))) + .collect(), + max_rewrite_mem_gib, + rewrite_peak_memory_bytes, + requested_rewrite_iters: rewrite_iters, + executed_rewrite_iters, + rewrite_stopped_early_due_to_memory_cap, + }; + if breakdown { + eprintln!( + "[bench-breakdown] math-microbenchmark total: {:?}", + t_total.elapsed() + ); + } + stats +} + +pub fn bench() { + let breakdown = std::env::var_os("EGGPLANT_BENCH_BREAKDOWN").is_some(); + let _ = run_and_collect_stats(breakdown); +} + +#[cfg(feature = "rustsat-extract")] +fn build_extract_target() -> impl EgglogNode + EgglogTy + 'static { + let five = MVar::::new("five".to_owned()); + five.commit(); + let one_a = MConst::::new(1); + one_a.commit(); + let one_b = MConst::::new(1); + one_b.commit(); + let one_c = MConst::::new(1); + one_c.commit(); + let two_a = MConst::::new(2); + two_a.commit(); + let two_b = MConst::::new(2); + two_b.commit(); + + let sqrt_five_a = MSqrt::::new(&five); + sqrt_five_a.commit(); + let add_1_sqrt = MAdd::::new(&one_a, &sqrt_five_a); + add_1_sqrt.commit(); + let div_add = MDiv::::new(&add_1_sqrt, &two_a); + div_add.commit(); + + let sqrt_five_b = MSqrt::::new(&five); + sqrt_five_b.commit(); + let sub_1_sqrt = MSub::::new(&one_b, &sqrt_five_b); + sub_1_sqrt.commit(); + let div_sub = MDiv::::new(&sub_1_sqrt, &two_b); + div_sub.commit(); + + let denom = MSub::::new(&div_add, &div_sub); + denom.commit(); + let root = MDiv::::new(&one_c, &denom); + root.commit(); + root +} + +#[cfg(feature = "rustsat-extract")] +fn benchmark_extract_backend( + target: &N, + method: &'static str, + rewrite_peak_memory_bytes: u64, + backend: ExtractBackend, +) -> MathExtractComparisonRow +where + N: EgglogNode + EgglogTy + 'static, +{ + let extract_peak_before = current_peak_memory_bytes(); + let started = Instant::now(); + let (rendered, cost) = MyTxMathNoCalc::extract_node_to_string_with_backend(target, backend) + .expect("math microbench extraction should succeed"); + let svg_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("target") + .join("math_microbench_extract_svgs"); + fs::create_dir_all(&svg_dir).expect("svg output directory should be creatable"); + let svg_path = svg_dir.join(format!("{method}.svg")); + let _ = MyTxMathNoCalc::extract_node_to_svg_with_backend( + target, + match method { + "default" => ExtractBackend::cost_model(TreeAdditiveCostModel::default()), + "eboost" => ExtractBackend::::eboost_heuristic( + EBoostExtractConfig::default(), + ), + "layered" => ExtractBackend::::eboost_layered( + EBoostLayeredConfig::default(), + ), + "rustsat" => { + ExtractBackend::::rustsat(RustsatExtractConfig::default()) + } + other => panic!("unsupported extract method `{other}`"), + }, + &svg_path, + ) + .expect("svg rendering should succeed for math microbench extract comparison"); + let extract_peak_after = current_peak_memory_bytes(); + MathExtractComparisonRow { + method, + requested_rewrite_iters: 0, + executed_rewrite_iters: 0, + max_rewrite_mem_gib: 0, + run_ruleset_note: String::new(), + rewrite_peak_memory_bytes, + extract_peak_memory_bytes: Some(extract_peak_after.saturating_sub(extract_peak_before)), + cost: Some(cost), + elapsed: Some(started.elapsed()), + rendered, + svg_path: svg_path.display().to_string(), + timed_out: false, + } +} + +#[cfg(feature = "rustsat-extract")] +#[derive(Debug, Clone, Serialize, Deserialize)] +struct TimedExtractComparisonPayload { + rendered: String, + cost: u64, + elapsed_ms: f64, + peak_memory_bytes: u64, + svg_path: String, +} + +#[cfg(feature = "rustsat-extract")] +fn benchmark_extract_backend_with_timeout( + target: &N, + method: &'static str, + rewrite_peak_memory_bytes: u64, + max_extract_time_secs: Option, +) -> MathExtractComparisonRow +where + N: EgglogNode + EgglogTy + 'static, +{ + let payload = run_with_timeout_payload( + max_extract_time_secs, + || { + let row = benchmark_extract_backend( + target, + method, + rewrite_peak_memory_bytes, + extract_backend_for_method(method), + ); + TimedExtractComparisonPayload { + rendered: row.rendered, + cost: row.cost.unwrap_or(0), + elapsed_ms: row.elapsed.map(duration_to_ms).unwrap_or(0.0), + peak_memory_bytes: row.extract_peak_memory_bytes.unwrap_or(0), + svg_path: row.svg_path, + } + }, + || TimedExtractComparisonPayload { + rendered: "NaN".to_string(), + cost: 0, + elapsed_ms: f64::NAN, + peak_memory_bytes: 0, + svg_path: "n/a".to_string(), + }, + ); + if payload.elapsed_ms.is_nan() { + MathExtractComparisonRow { + method, + requested_rewrite_iters: 0, + executed_rewrite_iters: 0, + max_rewrite_mem_gib: 0, + run_ruleset_note: String::new(), + rewrite_peak_memory_bytes, + extract_peak_memory_bytes: None, + cost: None, + elapsed: None, + rendered: "NaN".to_string(), + svg_path: "n/a".to_string(), + timed_out: true, + } + } else { + MathExtractComparisonRow { + method, + requested_rewrite_iters: 0, + executed_rewrite_iters: 0, + max_rewrite_mem_gib: 0, + run_ruleset_note: String::new(), + rewrite_peak_memory_bytes, + extract_peak_memory_bytes: Some(payload.peak_memory_bytes), + cost: Some(payload.cost), + elapsed: Some(duration_from_ms(payload.elapsed_ms)), + rendered: payload.rendered, + svg_path: payload.svg_path, + timed_out: false, + } + } +} + +#[cfg(feature = "rustsat-extract")] +fn measure_extract_metric( + target: &N, + iteration: usize, + method: &'static str, + backend: ExtractBackend, +) -> ExtractTimelineMetric +where + N: EgglogNode + EgglogTy + 'static, +{ + let extract_peak_before = current_peak_memory_bytes(); + let started = Instant::now(); + let (_rendered, cost) = MyTxMathNoCalc::extract_node_to_string_with_backend(target, backend) + .expect("timeline extract should succeed"); + let elapsed_ms = elapsed_ms(started); + let svg_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("target") + .join("math_microbench_timeline_svgs") + .join(format!("iter_{iteration:03}")); + fs::create_dir_all(&svg_dir).expect("timeline svg output directory should be creatable"); + let svg_path = svg_dir.join(format!("{method}.svg")); + let _ = MyTxMathNoCalc::extract_node_to_svg_with_backend( + target, + match method { + "default" => ExtractBackend::cost_model(TreeAdditiveCostModel::default()), + "eboost" => ExtractBackend::::eboost_heuristic( + EBoostExtractConfig::default(), + ), + "layered" => ExtractBackend::::eboost_layered( + EBoostLayeredConfig::default(), + ), + "rustsat" => { + ExtractBackend::::rustsat(RustsatExtractConfig::default()) + } + other => panic!("unsupported extract method `{other}`"), + }, + &svg_path, + ) + .expect("timeline svg rendering should succeed"); + let extract_peak_after = current_peak_memory_bytes(); + ExtractTimelineMetric { + method: method.to_string(), + cost: Some(cost), + elapsed_ms: Some(elapsed_ms), + peak_memory_bytes: Some(extract_peak_after.saturating_sub(extract_peak_before)), + svg_path: svg_path.display().to_string(), + timed_out: false, + } +} + +#[cfg(feature = "rustsat-extract")] +fn extract_backend_for_method(method: &'static str) -> ExtractBackend { + match method { + "default" => ExtractBackend::cost_model(TreeAdditiveCostModel::default()), + "eboost" => { + ExtractBackend::::eboost_heuristic(EBoostExtractConfig::default()) + } + "layered" => { + ExtractBackend::::eboost_layered(EBoostLayeredConfig::default()) + } + "rustsat" => { + ExtractBackend::::rustsat(RustsatExtractConfig::default()) + } + other => panic!("unsupported extract method `{other}`"), + } +} + +#[cfg(feature = "rustsat-extract")] +fn parse_extract_methods(methods: &[String]) -> Vec<&'static str> { + if methods.is_empty() { + return ALL_EXTRACT_METHODS.to_vec(); + } + methods + .iter() + .map(|method| match method.as_str() { + "default" => "default", + "eboost" => "eboost", + "layered" => "layered", + "rustsat" => "rustsat", + other => panic!("unsupported extract method `{other}`"), + }) + .collect() +} + +#[cfg(feature = "rustsat-extract")] +fn measure_extract_metric_with_timeout( + target: &N, + iteration: usize, + method: &'static str, + max_extract_time_secs: Option, +) -> ExtractTimelineMetric +where + N: EgglogNode + EgglogTy + 'static, +{ + run_with_timeout_payload( + max_extract_time_secs, + || { + measure_extract_metric( + target, + iteration, + method, + extract_backend_for_method(method), + ) + }, + || ExtractTimelineMetric { + method: method.to_string(), + cost: None, + elapsed_ms: None, + peak_memory_bytes: None, + svg_path: "n/a".to_string(), + timed_out: true, + }, + ) +} + +#[cfg(feature = "rustsat-extract")] +pub fn run_extract_comparison_with_iters_and_mem_cap( + rewrite_iters: usize, + max_rewrite_mem_gib: u64, +) -> Vec { + run_extract_comparison_with_options_and_progress( + rewrite_iters, + max_rewrite_mem_gib, + &[], + None, + |_| {}, + ) +} + +#[cfg(feature = "rustsat-extract")] +pub fn run_extract_comparison_with_options_and_progress( + rewrite_iters: usize, + max_rewrite_mem_gib: u64, + selected_extractors: &[String], + max_extract_time_secs: Option, + mut on_progress: F, +) -> Vec +where + F: FnMut(ProgressEvent), +{ + let extract_methods = parse_extract_methods(selected_extractors); + run_extract_comparison_with_iters_and_mem_cap_and_progress_detailed( + rewrite_iters, + max_rewrite_mem_gib, + &extract_methods, + max_extract_time_secs, + |event| on_progress(event), + ) +} + +#[cfg(feature = "rustsat-extract")] +pub fn run_extract_comparison_with_iters_and_mem_cap_and_progress( + rewrite_iters: usize, + max_rewrite_mem_gib: u64, + mut on_progress: F, +) -> Vec +where + F: FnMut(ProgressEvent), +{ + run_extract_comparison_with_iters_and_mem_cap_and_progress_detailed( + rewrite_iters, + max_rewrite_mem_gib, + ALL_EXTRACT_METHODS, + None, + |event| on_progress(event), + ) +} + +#[cfg(feature = "rustsat-extract")] +pub fn run_extract_comparison_with_iters_and_mem_cap_and_progress_detailed( + rewrite_iters: usize, + max_rewrite_mem_gib: u64, + extract_methods: &[&'static str], + max_extract_time_secs: Option, + mut on_progress: F, +) -> Vec +where + F: FnMut(ProgressEvent), +{ + let stats = run_and_collect_stats_iters_with_mem_cap_and_progress( + false, + rewrite_iters, + max_rewrite_mem_gib, + |event| on_progress(event), + ); + let target = build_extract_target(); + + let mut rows = Vec::new(); + let total_extract_methods = extract_methods.len(); + + for (index, method) in extract_methods.iter().enumerate() { + on_progress(ProgressEvent::ExtractPhaseStart { + method, + current: index + 1, + total: total_extract_methods, + }); + let mut row = benchmark_extract_backend_with_timeout( + &target, + method, + stats.rewrite_peak_memory_bytes, + max_extract_time_secs, + ); + row.requested_rewrite_iters = stats.requested_rewrite_iters; + row.executed_rewrite_iters = stats.executed_rewrite_iters; + row.max_rewrite_mem_gib = stats.max_rewrite_mem_gib; + row.run_ruleset_note = if stats.rewrite_stopped_early_due_to_memory_cap { + format!( + "stopped early at {} / {} iterations because peak memory exceeded {} GiB", + stats.executed_rewrite_iters, + stats.requested_rewrite_iters, + stats.max_rewrite_mem_gib + ) + } else { + "completed requested iterations".to_string() + }; + on_progress(ProgressEvent::ExtractPhaseComplete { + method, + current: index + 1, + total: total_extract_methods, + elapsed_ms: row.elapsed.map(duration_to_ms).unwrap_or(f64::NAN), + peak_memory_bytes: row.extract_peak_memory_bytes.unwrap_or(0), + }); + rows.push(row); + } + + rows +} + +#[cfg(feature = "rustsat-extract")] +pub fn run_extract_comparison_with_iters(rewrite_iters: usize) -> Vec { + run_extract_comparison_with_iters_and_mem_cap(rewrite_iters, DEFAULT_RUN_RULESET_MEMORY_CAP_GIB) +} + +#[cfg(feature = "rustsat-extract")] +pub fn run_extract_comparison() -> Vec { + run_extract_comparison_with_iters(11) +} + +#[cfg(feature = "rustsat-extract")] +pub fn run_extract_timeline_with_iters_and_mem_cap( + rewrite_iters: usize, + max_rewrite_mem_gib: u64, +) -> ExtractTimelineReport { + run_extract_timeline_with_options(rewrite_iters, max_rewrite_mem_gib, &[], None) +} + +#[cfg(feature = "rustsat-extract")] +pub fn run_extract_timeline_with_options( + rewrite_iters: usize, + max_rewrite_mem_gib: u64, + selected_extractors: &[String], + max_extract_time_secs: Option, +) -> ExtractTimelineReport { + let max_rewrite_mem_bytes = gib_to_bytes(max_rewrite_mem_gib); + let extract_methods = parse_extract_methods(selected_extractors); + + MyTxMathNoCalc::reset_for_bench(); + + let seed = MyTxMathNoCalc::new_ruleset("math_microbenchmark_no_calculus_timeline_seed"); + MyTxMathNoCalc::add_rule( + "math_microbenchmark_no_calculus_timeline_seed", + seed, + || { + #[eggplant::pat_vars_catch] + struct Unit {} + }, + |ctx, _pat| { + let x = ctx.insert_m_var("x".to_owned()); + let y = ctx.insert_m_var("y".to_owned()); + let five = ctx.insert_m_var("five".to_owned()); + + let add_x_y = ctx.insert_m_add(x.clone(), y.clone()); + let mul_y_add = ctx.insert_m_mul(y.clone(), add_x_y); + let add_x_2 = ctx.insert_m_add(x.clone(), ctx.insert_m_const(2)); + let add_x_x = ctx.insert_m_add(x.clone(), x.clone()); + let sub_add = ctx.insert_m_sub(add_x_2, add_x_x); + ctx.insert_m_add(mul_y_add, sub_add); + + let c1 = ctx.insert_m_const(1); + let c2 = ctx.insert_m_const(2); + let sqrt_five = ctx.insert_m_sqrt(five.clone()); + let add_1_sqrt = ctx.insert_m_add(c1, sqrt_five.clone()); + let div_add = ctx.insert_m_div(add_1_sqrt, c2); + let sub_1_sqrt = ctx.insert_m_sub(ctx.insert_m_const(1), sqrt_five); + let div_sub = ctx.insert_m_div(sub_1_sqrt, ctx.insert_m_const(2)); + let denom = ctx.insert_m_sub(div_add, div_sub); + ctx.insert_m_div(ctx.insert_m_const(1), denom); + }, + ); + MyTxMathNoCalc::run_ruleset(seed, RunConfig::Once); + + let target = build_extract_target(); + + let rs = MyTxMathNoCalc::new_ruleset("math_microbenchmark_no_calculus_timeline_rules"); + register_rewrite_rules( + rs, + "sub_self", + "distribute_mul", + "factor_mul", + "pow_mul_same_base", + ); + + let mut points = Vec::new(); + let mut executed_rewrite_iters = 0usize; + let mut stopped_early_due_to_memory_cap = false; + let rewrite_peak_before = current_peak_memory_bytes(); + for iteration in 1..=rewrite_iters { + let started = Instant::now(); + let report = MyTxMathNoCalc::run_ruleset(rs, RunConfig::Once); + let rewrite_elapsed_ms = elapsed_ms(started); + executed_rewrite_iters += 1; + let current_peak = current_peak_memory_bytes(); + let tuple_count = { + let egraph = ::egraph(); + let egraph = egraph.lock().unwrap(); + egraph.num_tuples() + }; + let rule_matches = report + .num_matches_per_rule + .iter() + .map(|(name, count)| (name.to_string(), *count)) + .collect::>(); + let extracts = extract_methods + .iter() + .map(|method| { + measure_extract_metric_with_timeout( + &target, + iteration, + method, + max_extract_time_secs, + ) + }) + .collect::>(); + points.push(RewriteTimelinePoint { + iteration, + tuple_count, + rewrite_elapsed_ms, + rewrite_peak_memory_bytes: current_peak.saturating_sub(rewrite_peak_before), + rule_matches, + extracts, + }); + if current_peak > max_rewrite_mem_bytes { + stopped_early_due_to_memory_cap = true; + break; + } + } + + ExtractTimelineReport { + version_nickname: None, + selected_extractors: extract_methods.iter().map(|m| (*m).to_string()).collect(), + max_extract_time_secs, + requested_rewrite_iters: rewrite_iters, + executed_rewrite_iters, + max_rewrite_mem_gib, + stopped_early_due_to_memory_cap, + points, + } +} + +pub fn run_div_add_rewrite_smoke(rewrite_iters: usize, cost_model: CM) -> String +where + CM: eggplant::egglog::extract::CostModel + 'static, +{ + MyTxMathNoCalc::reset_for_bench(); + + let one = MConst::::new(1); + one.commit(); + let x = MVar::::new("x".to_owned()); + x.commit(); + let two = MConst::::new(2); + two.commit(); + let add = MAdd::::new(&one, &x); + add.commit(); + let root = MDiv::::new(&add, &two); + root.commit(); + + let rs = MyTxMathNoCalc::new_ruleset("math_microbenchmark_div_add_smoke"); + { + MyTxMathNoCalc::add_rule( + "div_add_distrib_smoke", + rs, + || { + let a = MathNoCalc::query_leaf(); + let b = MathNoCalc::query_leaf(); + let c = MathNoCalc::query_leaf(); + let add = MAdd::query(&a, &b); + let div = MDiv::query(&add, &c); + #[eggplant::pat_vars] + struct Pat { + a: MathNoCalc, + b: MathNoCalc, + c: MathNoCalc, + div: MDiv, + } + Pat::new(a, b, c, div) + }, + |ctx, pat| { + let a_div_c = ctx.insert_m_div(pat.a, pat.c); + let b_div_c = ctx.insert_m_div(pat.b, pat.c); + let rhs = ctx.insert_m_add(a_div_c, b_div_c); + ctx.union(pat.div, rhs); + }, + ); + }; + + for _ in 0..rewrite_iters { + MyTxMathNoCalc::run_ruleset(rs, RunConfig::Once); + } + + let (rendered, _) = MyTxMathNoCalc::extract_node_to_string_with_cost_model(&root, cost_model) + .expect("smoke extract should succeed"); + rendered +} + +pub fn run_cancel_neg_add_rewrite_smoke(rewrite_iters: usize, cost_model: CM) -> String +where + CM: eggplant::egglog::extract::CostModel + 'static, +{ + MyTxMathNoCalc::reset_for_bench(); + + let x = MVar::::new("x".to_owned()); + x.commit(); + let neg_one = MConst::::new(-1); + neg_one.commit(); + let neg_x = MMul::::new(&neg_one, &x); + neg_x.commit(); + let root = MAdd::::new(&x, &neg_x); + root.commit(); + + let rs = MyTxMathNoCalc::new_ruleset("math_microbenchmark_cancel_neg_add_smoke"); + MyTxMathNoCalc::add_rule( + "add_neg_self_zero_smoke", + rs, + || { + let a = MathNoCalc::query_leaf(); + let b = MathNoCalc::query_leaf(); + let neg_one = MConst::query(); + let neg_b = MMul::query(&neg_one, &b); + let add = MAdd::query(&a, &neg_b); + let is_neg_one = neg_one.handle_n().eq(&-1_i64); + let same_term = a.handle().eq(&b.handle()); + #[eggplant::pat_vars] + struct Pat { + a: MathNoCalc, + b: MathNoCalc, + neg_one: MConst, + add: MAdd, + } + Pat::new(a, b, neg_one, add) + .assert(is_neg_one) + .assert(same_term) + }, + |ctx, pat| { + let z = ctx.insert_m_const(0); + ctx.union(pat.add, z); + }, + ); + + for _ in 0..rewrite_iters { + MyTxMathNoCalc::run_ruleset(rs, RunConfig::Once); + } + + let (rendered, _) = MyTxMathNoCalc::extract_node_to_string_with_cost_model(&root, cost_model) + .expect("cancel-neg smoke extract should succeed"); + rendered +} diff --git a/benches/runners/eggplant_rewrite/merge_during_rebuild.rs b/benches/runners/eggplant_rewrite/merge_during_rebuild.rs index d15a959..8ed22cc 100644 --- a/benches/runners/eggplant_rewrite/merge_during_rebuild.rs +++ b/benches/runners/eggplant_rewrite/merge_during_rebuild.rs @@ -3,8 +3,8 @@ use eggplant::tx_rx_vt_pr; #[eggplant::dsl] enum N { - #[eggplant::typst("Node({i})")] - #[eggplant::precedence(100)] + #[typst("Node({i})")] + #[precedence(100)] Node { i: i64 }, } diff --git a/benches/runners/eggplant_rewrite/repro_665_set_union.rs b/benches/runners/eggplant_rewrite/repro_665_set_union.rs index cd06f1c..b3c6276 100644 --- a/benches/runners/eggplant_rewrite/repro_665_set_union.rs +++ b/benches/runners/eggplant_rewrite/repro_665_set_union.rs @@ -9,8 +9,8 @@ struct IntSet { #[eggplant::dsl] enum RRel { - #[eggplant::typst("R({i})")] - #[eggplant::precedence(100)] + #[typst("R({i})")] + #[precedence(100)] R { i: i64 }, } @@ -20,17 +20,6 @@ struct f {} tx_rx_vt_pr!(MyTxRepro, MyPatRecRepro); -#[eggplant::pat_vars] -struct StepPat { - r: R, -} - -fn step_pat() -> StepPat { - let r = R::query(); - let constraint = r.handle_i().lt(&2000); - StepPat::new(r).assert(constraint) -} - pub fn bench() { MyTxRepro::reset_for_bench(); @@ -48,14 +37,27 @@ pub fn bench() { ); let step = MyTxRepro::new_ruleset("repro_665_step"); - MyTxRepro::add_rule("repro_665_step", step, step_pat, |ctx, pat| { - let i = ctx.devalue(pat.r.i); - ctx.insert_r(i + 1); + MyTxRepro::add_rule( + "repro_665_step", + step, + || { + let r = R::query(); + let below_limit = r.handle_i().lt(&2000); + #[eggplant::pat_vars] + struct Pat { + r: R, + } + Pat::new(r).assert(below_limit) + }, + |ctx, pat| { + let i = ctx.devalue(pat.r.i); + ctx.insert_r(i + 1); - let mut set = SetContainer::::new(); - set.insert(pat.r.i); - ctx.set_f(set); - }); + let mut set = SetContainer::::new(); + set.insert(pat.r.i); + ctx.set_f(set); + }, + ); MyTxRepro::run_ruleset(seed, RunConfig::Once); MyTxRepro::run_ruleset(step, RunConfig::Sat); diff --git a/benches/runners/eggplant_rewrite/vec_builtins.rs b/benches/runners/eggplant_rewrite/vec_builtins.rs index b5e477a..211a144 100644 --- a/benches/runners/eggplant_rewrite/vec_builtins.rs +++ b/benches/runners/eggplant_rewrite/vec_builtins.rs @@ -9,11 +9,11 @@ struct IVec { #[eggplant::dsl] enum X { - #[eggplant::typst("a")] - #[eggplant::precedence(100)] + #[typst("a")] + #[precedence(100)] a {}, - #[eggplant::typst("b")] - #[eggplant::precedence(100)] + #[typst("b")] + #[precedence(100)] b {}, } @@ -30,19 +30,6 @@ struct Q {} tx_rx_vt_pr!(MyTxVec, MyPatRecVec); -#[eggplant::pat_vars] -struct CheckIVecPat { - v: BaseVar, -} - -#[eggplant::pat_vars] -struct CheckUnitPat {} - -#[eggplant::pat_vars] -struct CheckI64Pat { - v: BaseVar, -} - fn expect_rule_matches(report: &RunReport, rule: &str) { let key = format!("@{rule}"); assert!( @@ -56,63 +43,6 @@ fn expect_rule_matches(report: &RunReport, rule: &str) { ); } -fn pat_vec_check_vec_of() -> CheckIVecPat { - let v = BaseVar::::query_named("v"); - let vh = v.handle(); - let e1 = vec_of::([&1_i64, &2_i64]); - let e2 = vec_empty::().vec_push(&1_i64).vec_push(&2_i64); - CheckIVecPat::new(v).assert(vh.eq(&e1)).assert(vh.eq(&e2)) -} - -fn pat_vec_check_vec_append() -> CheckIVecPat { - let v = BaseVar::::query_named("v"); - let vh = v.handle(); - let lhs = - vec_of::([&1_i64, &2_i64]).vec_append(vec_of::([&3_i64, &4_i64])); - let rhs = vec_of::([&1_i64, &2_i64, &3_i64, &4_i64]); - CheckIVecPat::new(v).assert(vh.eq(&lhs)).assert(vh.eq(&rhs)) -} - -fn pat_vec_check_vec_pop() -> CheckIVecPat { - let v = BaseVar::::query_named("v"); - let vh = v.handle(); - let lhs = vec_of::([&1_i64, &2_i64, &3_i64]).vec_pop(); - let rhs = vec_of::([&1_i64, &2_i64]); - CheckIVecPat::new(v).assert(vh.eq(&lhs)).assert(vh.eq(&rhs)) -} - -fn pat_vec_check_vec_not_contains() -> CheckUnitPat { - let e = vec_of::([&1_i64, &2_i64, &3_i64]).vec_not_contains(&4_i64); - CheckUnitPat::new().assert(e) -} - -fn pat_vec_check_vec_contains() -> CheckUnitPat { - let e = vec_of::([&1_i64, &2_i64, &3_i64]).vec_contains(&2_i64); - CheckUnitPat::new().assert(e) -} - -fn pat_vec_check_vec_length() -> CheckI64Pat { - let v = BaseVar::::query_named("n"); - let vh = v.handle(); - let e = vec_of::([&1_i64, &2_i64, &3_i64]).vec_len(); - CheckI64Pat::new(v).assert(vh.eq(&e)).assert(vh.eq(&3_i64)) -} - -fn pat_vec_check_vec_get() -> CheckI64Pat { - let v = BaseVar::::query_named("n"); - let vh = v.handle(); - let e = vec_of::([&1_i64, &2_i64, &3_i64]).vec_get(&1_i64); - CheckI64Pat::new(v).assert(vh.eq(&e)).assert(vh.eq(&2_i64)) -} - -fn pat_vec_check_vec_set() -> CheckIVecPat { - let v = BaseVar::::query_named("v"); - let vh = v.handle(); - let lhs = vec_of::([&1_i64, &2_i64, &3_i64]).vec_set(&1_i64, &4_i64); - let rhs = vec_of::([&1_i64, &4_i64, &3_i64]); - CheckIVecPat::new(v).assert(vh.eq(&lhs)).assert(vh.eq(&rhs)) -} - pub fn bench() { MyTxVec::reset_for_bench(); @@ -122,7 +52,17 @@ pub fn bench() { MyTxVec::add_rule( "vec_check_vec_of", rs, - pat_vec_check_vec_of, + || { + let v = BaseVar::::query_named("v"); + let vh = v.handle(); + let e1 = vec_of::([&1_i64, &2_i64]); + let e2 = vec_empty::().vec_push(&1_i64).vec_push(&2_i64); + #[eggplant::pat_vars] + struct Pat { + v: BaseVar, + } + Pat::new(v).assert(vh.eq(&e1)).assert(vh.eq(&e2)) + }, |_ctx, _pat| {}, ); @@ -130,7 +70,18 @@ pub fn bench() { MyTxVec::add_rule( "vec_check_vec_append", rs, - pat_vec_check_vec_append, + || { + let v = BaseVar::::query_named("v"); + let vh = v.handle(); + let lhs = vec_of::([&1_i64, &2_i64]) + .vec_append(vec_of::([&3_i64, &4_i64])); + let rhs = vec_of::([&1_i64, &2_i64, &3_i64, &4_i64]); + #[eggplant::pat_vars] + struct Pat { + v: BaseVar, + } + Pat::new(v).assert(vh.eq(&lhs)).assert(vh.eq(&rhs)) + }, |_ctx, _pat| {}, ); @@ -138,7 +89,17 @@ pub fn bench() { MyTxVec::add_rule( "vec_check_vec_pop", rs, - pat_vec_check_vec_pop, + || { + let v = BaseVar::::query_named("v"); + let vh = v.handle(); + let lhs = vec_of::([&1_i64, &2_i64, &3_i64]).vec_pop(); + let rhs = vec_of::([&1_i64, &2_i64]); + #[eggplant::pat_vars] + struct Pat { + v: BaseVar, + } + Pat::new(v).assert(vh.eq(&lhs)).assert(vh.eq(&rhs)) + }, |_ctx, _pat| {}, ); @@ -146,7 +107,12 @@ pub fn bench() { MyTxVec::add_rule( "vec_check_vec_not_contains", rs, - pat_vec_check_vec_not_contains, + || { + let e = vec_of::([&1_i64, &2_i64, &3_i64]).vec_not_contains(&4_i64); + #[eggplant::pat_vars] + struct Pat {} + Pat::new().assert(e) + }, |_ctx, _pat| {}, ); @@ -154,7 +120,12 @@ pub fn bench() { MyTxVec::add_rule( "vec_check_vec_contains", rs, - pat_vec_check_vec_contains, + || { + let e = vec_of::([&1_i64, &2_i64, &3_i64]).vec_contains(&2_i64); + #[eggplant::pat_vars] + struct Pat {} + Pat::new().assert(e) + }, |_ctx, _pat| {}, ); @@ -162,7 +133,16 @@ pub fn bench() { MyTxVec::add_rule( "vec_check_vec_length", rs, - pat_vec_check_vec_length, + || { + let v = BaseVar::::query_named("n"); + let vh = v.handle(); + let e = vec_of::([&1_i64, &2_i64, &3_i64]).vec_len(); + #[eggplant::pat_vars] + struct Pat { + v: BaseVar, + } + Pat::new(v).assert(vh.eq(&e)).assert(vh.eq(&3_i64)) + }, |_ctx, _pat| {}, ); @@ -170,7 +150,16 @@ pub fn bench() { MyTxVec::add_rule( "vec_check_vec_get", rs, - pat_vec_check_vec_get, + || { + let v = BaseVar::::query_named("n"); + let vh = v.handle(); + let e = vec_of::([&1_i64, &2_i64, &3_i64]).vec_get(&1_i64); + #[eggplant::pat_vars] + struct Pat { + v: BaseVar, + } + Pat::new(v).assert(vh.eq(&e)).assert(vh.eq(&2_i64)) + }, |_ctx, _pat| {}, ); @@ -178,7 +167,17 @@ pub fn bench() { MyTxVec::add_rule( "vec_check_vec_set", rs, - pat_vec_check_vec_set, + || { + let v = BaseVar::::query_named("v"); + let vh = v.handle(); + let lhs = vec_of::([&1_i64, &2_i64, &3_i64]).vec_set(&1_i64, &4_i64); + let rhs = vec_of::([&1_i64, &4_i64, &3_i64]); + #[eggplant::pat_vars] + struct Pat { + v: BaseVar, + } + Pat::new(v).assert(vh.eq(&lhs)).assert(vh.eq(&rhs)) + }, |_ctx, _pat| {}, ); diff --git a/benches/runners/eggplant_rewrite/web_demo_set.rs b/benches/runners/eggplant_rewrite/web_demo_set.rs index 5735061..2742cc7 100644 --- a/benches/runners/eggplant_rewrite/web_demo_set.rs +++ b/benches/runners/eggplant_rewrite/web_demo_set.rs @@ -10,8 +10,8 @@ struct ISetBase { #[eggplant::dsl] enum SeenIdx { - #[eggplant::typst("Seen({j})")] - #[eggplant::precedence(100)] + #[typst("Seen({j})")] + #[precedence(100)] Seen { j: i64 }, } @@ -82,165 +82,6 @@ fn bind_const_set( var } -#[eggplant::pat_vars] -struct CheckSetInsertPat { - expected: BaseVar, - empty: BaseVar, -} - -fn pat_set_check_set_of_12_push_12() -> CheckSetInsertPat { - let expected = bind_const_set::("S12", BaseVar::::query_named("s12")); - let empty = bind_const_set::("SEmpty", BaseVar::::query_named("empty")); - let expected_h = expected.handle(); - let empty_h = empty.handle(); - - let rhs = empty_h.clone().set_insert(&1_i64).set_insert(&2_i64); - - CheckSetInsertPat::new(expected, empty).assert(expected_h.eq(&rhs)) -} - -fn pat_set_check_set_of_12_push_21() -> CheckSetInsertPat { - let expected = bind_const_set::("S12", BaseVar::::query_named("s12")); - let empty = bind_const_set::("SEmpty", BaseVar::::query_named("empty")); - let expected_h = expected.handle(); - let empty_h = empty.handle(); - - let rhs = empty_h.clone().set_insert(&2_i64).set_insert(&1_i64); - - CheckSetInsertPat::new(expected, empty).assert(expected_h.eq(&rhs)) -} - -#[eggplant::pat_vars] -struct CheckSetUnionPat { - s12: BaseVar, - s34: BaseVar, - expected: BaseVar, -} - -fn pat_set_check_set_union_1234() -> CheckSetUnionPat { - let s12 = bind_const_set::("S12", BaseVar::::query_named("s12")); - let s34 = bind_const_set::("S34", BaseVar::::query_named("s34")); - let expected = bind_const_set::("S1234", BaseVar::::query_named("s1234")); - let expected_h = expected.handle(); - - let lhs = s12.handle().set_union(s34.handle()); - - CheckSetUnionPat::new(s12, s34, expected).assert(expected_h.eq(&lhs)) -} - -#[eggplant::pat_vars] -struct CheckSetLenPat { - set: BaseVar, -} - -fn pat_set_check_set_length_empty_0() -> CheckSetLenPat { - let set = bind_const_set::("SEmpty", BaseVar::::query_named("s")); - let len = set.handle().set_len(); - CheckSetLenPat::new(set).assert(len.eq(&0_i64)) -} - -fn pat_set_check_set_length_of_111_1() -> CheckSetLenPat { - let set = bind_const_set::("S111", BaseVar::::query_named("s")); - let len = set.handle().set_len(); - CheckSetLenPat::new(set).assert(len.eq(&1_i64)) -} - -fn pat_set_check_set_length_of_1m111_2() -> CheckSetLenPat { - let set = bind_const_set::("S1m111", BaseVar::::query_named("s")); - let len = set.handle().set_len(); - CheckSetLenPat::new(set).assert(len.eq(&2_i64)) -} - -#[eggplant::pat_vars] -struct CheckSetGetPat { - set: BaseVar, -} - -fn pat_set_check_set_get_1m1241_0_is_1() -> CheckSetGetPat { - let set = bind_const_set::("S1m1241", BaseVar::::query_named("s")); - let got = set.handle().set_get(&0_i64); - CheckSetGetPat::new(set).assert(got.eq(&1_i64)) -} - -fn pat_set_check_set_get_1m1241_1_is_2() -> CheckSetGetPat { - let set = bind_const_set::("S1m1241", BaseVar::::query_named("s")); - let got = set.handle().set_get(&1_i64); - CheckSetGetPat::new(set).assert(got.eq(&2_i64)) -} - -fn pat_set_check_set_get_1m1241_2_is_4() -> CheckSetGetPat { - let set = bind_const_set::("S1m1241", BaseVar::::query_named("s")); - let got = set.handle().set_get(&2_i64); - CheckSetGetPat::new(set).assert(got.eq(&4_i64)) -} - -fn pat_set_check_set_get_1m1241_3_is_m1() -> CheckSetGetPat { - let set = bind_const_set::("S1m1241", BaseVar::::query_named("s")); - let got = set.handle().set_get(&3_i64); - CheckSetGetPat::new(set).assert(got.eq(&-1_i64)) -} - -// Reify rules. -#[eggplant::pat_vars] -struct Reify0Pat { - x: BaseVar, - y: BaseVar, -} - -fn reify0_pat() -> Reify0Pat { - let x = BaseVar::::query_named("x"); - let y = BaseVar::::query_named("y"); - let yh = y.handle(); - - // Bind `x` by reading the 0-arg "global" function `Myset()` (replaces egglog's `$myset`). - // - // Without a table-fact assignment like this, `x` would be an unassigned variable and the - // rule would fail egglog's rule typechecking. - MyPatRecSet::on_new_table_fact( - "Myset".to_string(), - vec![(x.name(), "ISetBase".to_string())], - ); - - let len = x.handle().set_len(); - let y_expr = x.handle().set_get(&0_i64); - - Reify0Pat::new(x, y) - .assert(len.gt(&0_i64)) - .assert(yh.eq(&y_expr)) -} - -#[eggplant::pat_vars] -struct ReifyStepPat { - seen: Seen, - x: BaseVar, - i: BaseVar, - y: BaseVar, -} - -fn reify_step_pat() -> ReifyStepPat { - let seen = Seen::query(); - let x = BaseVar::::query_named("x"); - let i = BaseVar::::query_named("i"); - let y = BaseVar::::query_named("y"); - let ih = i.handle(); - let yh = y.handle(); - - // Same `Myset()` binding as `reify0_pat`. - MyPatRecSet::on_new_table_fact( - "Myset".to_string(), - vec![(x.name(), "ISetBase".to_string())], - ); - - let i_expr = seen.handle_j() + (&1_i64).as_handle(); - let len = x.handle().set_len(); - let y_expr = x.handle().set_get(&ih); - - ReifyStepPat::new(seen, x, i, y) - .assert(ih.eq(&i_expr)) - .assert(ih.lt(&len)) - .assert(yh.eq(&y_expr)) -} - pub fn bench() { let breakdown = std::env::var_os("EGGPLANT_BENCH_BREAKDOWN").is_some(); let t_total = Instant::now(); @@ -341,61 +182,193 @@ pub fn bench() { MyTxSet::add_rule( "set_check_set_of_12_push_12", checks, - pat_set_check_set_of_12_push_12, + || { + let expected = bind_const_set::( + "S12", + BaseVar::::query_named("s12"), + ); + let empty = bind_const_set::( + "SEmpty", + BaseVar::::query_named("empty"), + ); + let expected_h = expected.handle(); + let rhs = empty.handle().set_insert(&1_i64).set_insert(&2_i64); + #[eggplant::pat_vars] + struct Pat { + expected: BaseVar, + empty: BaseVar, + } + Pat::new(expected, empty).assert(expected_h.eq(&rhs)) + }, |_ctx, _pat| {}, ); MyTxSet::add_rule( "set_check_set_of_12_push_21", checks, - pat_set_check_set_of_12_push_21, + || { + let expected = bind_const_set::( + "S12", + BaseVar::::query_named("s12"), + ); + let empty = bind_const_set::( + "SEmpty", + BaseVar::::query_named("empty"), + ); + let expected_h = expected.handle(); + let rhs = empty.handle().set_insert(&2_i64).set_insert(&1_i64); + #[eggplant::pat_vars] + struct Pat { + expected: BaseVar, + empty: BaseVar, + } + Pat::new(expected, empty).assert(expected_h.eq(&rhs)) + }, |_ctx, _pat| {}, ); MyTxSet::add_rule( "set_check_set_union_1234", checks, - pat_set_check_set_union_1234, + || { + let s12 = bind_const_set::( + "S12", + BaseVar::::query_named("s12"), + ); + let s34 = bind_const_set::( + "S34", + BaseVar::::query_named("s34"), + ); + let expected = bind_const_set::( + "S1234", + BaseVar::::query_named("s1234"), + ); + let lhs = s12.handle().set_union(s34.handle()); + #[eggplant::pat_vars] + struct Pat { + s12: BaseVar, + s34: BaseVar, + expected: BaseVar, + } + Pat::new(s12, s34, expected).assert(expected.handle().eq(&lhs)) + }, |_ctx, _pat| {}, ); MyTxSet::add_rule( "set_check_set_length_empty_0", checks, - pat_set_check_set_length_empty_0, + || { + let set = bind_const_set::( + "SEmpty", + BaseVar::::query_named("s"), + ); + let len = set.handle().set_len(); + #[eggplant::pat_vars] + struct Pat { + set: BaseVar, + } + Pat::new(set).assert(len.eq(&0_i64)) + }, |_ctx, _pat| {}, ); MyTxSet::add_rule( "set_check_set_length_of_111_1", checks, - pat_set_check_set_length_of_111_1, + || { + let set = bind_const_set::( + "S111", + BaseVar::::query_named("s"), + ); + let len = set.handle().set_len(); + #[eggplant::pat_vars] + struct Pat { + set: BaseVar, + } + Pat::new(set).assert(len.eq(&1_i64)) + }, |_ctx, _pat| {}, ); MyTxSet::add_rule( "set_check_set_length_of_1m111_2", checks, - pat_set_check_set_length_of_1m111_2, + || { + let set = bind_const_set::( + "S1m111", + BaseVar::::query_named("s"), + ); + let len = set.handle().set_len(); + #[eggplant::pat_vars] + struct Pat { + set: BaseVar, + } + Pat::new(set).assert(len.eq(&2_i64)) + }, |_ctx, _pat| {}, ); MyTxSet::add_rule( "set_check_set_get_1m1241_0_is_1", checks, - pat_set_check_set_get_1m1241_0_is_1, + || { + let set = bind_const_set::( + "S1m1241", + BaseVar::::query_named("s"), + ); + let got = set.handle().set_get(&0_i64); + #[eggplant::pat_vars] + struct Pat { + set: BaseVar, + } + Pat::new(set).assert(got.eq(&1_i64)) + }, |_ctx, _pat| {}, ); MyTxSet::add_rule( "set_check_set_get_1m1241_1_is_2", checks, - pat_set_check_set_get_1m1241_1_is_2, + || { + let set = bind_const_set::( + "S1m1241", + BaseVar::::query_named("s"), + ); + let got = set.handle().set_get(&1_i64); + #[eggplant::pat_vars] + struct Pat { + set: BaseVar, + } + Pat::new(set).assert(got.eq(&2_i64)) + }, |_ctx, _pat| {}, ); MyTxSet::add_rule( "set_check_set_get_1m1241_2_is_4", checks, - pat_set_check_set_get_1m1241_2_is_4, + || { + let set = bind_const_set::( + "S1m1241", + BaseVar::::query_named("s"), + ); + let got = set.handle().set_get(&2_i64); + #[eggplant::pat_vars] + struct Pat { + set: BaseVar, + } + Pat::new(set).assert(got.eq(&4_i64)) + }, |_ctx, _pat| {}, ); MyTxSet::add_rule( "set_check_set_get_1m1241_3_is_m1", checks, - pat_set_check_set_get_1m1241_3_is_m1, + || { + let set = bind_const_set::( + "S1m1241", + BaseVar::::query_named("s"), + ); + let got = set.handle().set_get(&3_i64); + #[eggplant::pat_vars] + struct Pat { + set: BaseVar, + } + Pat::new(set).assert(got.eq(&-1_i64)) + }, |_ctx, _pat| {}, ); if breakdown { @@ -479,26 +452,71 @@ pub fn bench() { let t_reify_setup = Instant::now(); let reify = MyTxSet::new_ruleset("web_demo_set_reify"); - MyTxSet::add_rule("web_demo_set_reify0", reify, reify0_pat, |ctx, pat| { - // Manual `ISet-get` access (declared via inventory above). - // - // Generated `ctx.set_i_set_get` helpers are unavailable because base-container sorts - // can't currently be used as `#[eggplant::func]` inputs. - let key = [pat.x.erase(), ctx.intern_base::(0_i64).erase()]; - if ctx.lookup("ISet-get", &key).is_none() { - let row = [ - pat.x.erase(), - ctx.intern_base::(0_i64).erase(), - pat.y.erase(), - ]; - ctx.insert_func_tbl("ISet-get", &row); - ctx.insert_seen(0); - } - }); + MyTxSet::add_rule( + "web_demo_set_reify0", + reify, + || { + let x = BaseVar::::query_named("x"); + let y = BaseVar::::query_named("y"); + MyPatRecSet::on_new_table_fact( + "Myset".to_string(), + vec![(x.name(), "ISetBase".to_string())], + ); + let len = x.handle().set_len(); + let y_expr = x.handle().set_get(&0_i64); + #[eggplant::pat_vars] + struct Pat { + x: BaseVar, + y: BaseVar, + } + Pat::new(x, y) + .assert(len.gt(&0_i64)) + .assert(y.handle().eq(&y_expr)) + }, + |ctx, pat| { + // Manual `ISet-get` access (declared via inventory above). + // + // Generated `ctx.set_i_set_get` helpers are unavailable because base-container sorts + // can't currently be used as `#[eggplant::func]` inputs. + let key = [pat.x.erase(), ctx.intern_base::(0_i64).erase()]; + if ctx.lookup("ISet-get", &key).is_none() { + let row = [ + pat.x.erase(), + ctx.intern_base::(0_i64).erase(), + pat.y.erase(), + ]; + ctx.insert_func_tbl("ISet-get", &row); + ctx.insert_seen(0); + } + }, + ); MyTxSet::add_rule( "web_demo_set_reify_step", reify, - reify_step_pat, + || { + let seen = Seen::query(); + let x = BaseVar::::query_named("x"); + let i = BaseVar::::query_named("i"); + let y = BaseVar::::query_named("y"); + MyPatRecSet::on_new_table_fact( + "Myset".to_string(), + vec![(x.name(), "ISetBase".to_string())], + ); + let i_expr = seen.handle_j() + (&1_i64).as_handle(); + let len = x.handle().set_len(); + let y_expr = x.handle().set_get(&i.handle()); + #[eggplant::pat_vars] + struct Pat { + seen: Seen, + x: BaseVar, + i: BaseVar, + y: BaseVar, + } + Pat::new(seen, x, i, y) + .assert(i.handle().eq(&i_expr)) + .assert(i.handle().lt(&len)) + .assert(y.handle().eq(&y_expr)) + }, |ctx, pat| { let i = ctx._devalue_base::(pat.i.erase()); let key = [pat.x.erase(), pat.i.erase()]; diff --git a/benches/runners/eggplant_rewrite/web_demo_unify.rs b/benches/runners/eggplant_rewrite/web_demo_unify.rs index 63a5912..c4850fe 100644 --- a/benches/runners/eggplant_rewrite/web_demo_unify.rs +++ b/benches/runners/eggplant_rewrite/web_demo_unify.rs @@ -3,57 +3,19 @@ use eggplant::tx_rx_vt_pr; #[eggplant::dsl] enum Expr { - #[eggplant::typst("({l}) * ({r})")] - #[eggplant::precedence(60)] + #[typst("({l}) * ({r})")] + #[precedence(60)] Mul { l: Expr, r: Expr }, - #[eggplant::typst("{name}")] - #[eggplant::precedence(100)] + #[typst("{name}")] + #[precedence(100)] Var { name: String }, - #[eggplant::typst("{n}")] - #[eggplant::precedence(100)] + #[typst("{n}")] + #[precedence(100)] Lit { n: i64 }, } tx_rx_vt_pr!(MyTxUnify, MyPatRecUnify); -#[eggplant::pat_vars] -struct MulInjPat { - a: Expr, - b: Expr, - c: Expr, - d: Expr, - _m1: Mul, - _m2: Mul, -} - -fn mul_inj_pat() -> MulInjPat { - let a = Expr::query_leaf(); - let b = Expr::query_leaf(); - let c = Expr::query_leaf(); - let d = Expr::query_leaf(); - let m1 = Mul::query(&a, &b); - let m2 = Mul::query(&c, &d); - let constraint = m1.handle().eq(&m2.handle()); - MulInjPat::new(a, b, c, d, m1, m2).assert(constraint) -} - -#[eggplant::pat_vars] -struct LitEqMulPat { - a: Expr, - b: Expr, - _lit: Lit, - _mul: Mul, -} - -fn lit_eq_mul_pat() -> LitEqMulPat { - let a = Expr::query_leaf(); - let b = Expr::query_leaf(); - let lit = Lit::query(); - let mul = Mul::query(&a, &b); - let constraint = lit.handle().eq(&mul.handle()); - LitEqMulPat::new(a, b, lit, mul).assert(constraint) -} - pub fn bench() { MyTxUnify::reset_for_bench(); @@ -76,13 +38,55 @@ pub fn bench() { ); let step = MyTxUnify::new_ruleset("unify_step"); - MyTxUnify::add_rule("mul_injective", step, mul_inj_pat, |ctx, pat| { - ctx.union(pat.a, pat.c); - ctx.union(pat.b, pat.d); - }); - MyTxUnify::add_rule("lit_eq_mul_panic", step, lit_eq_mul_pat, |_ctx, _pat| { - panic!("Literal cannot be equal to a product"); - }); + MyTxUnify::add_rule( + "mul_injective", + step, + || { + let a = Expr::query_leaf(); + let b = Expr::query_leaf(); + let c = Expr::query_leaf(); + let d = Expr::query_leaf(); + let m1 = Mul::query(&a, &b); + let m2 = Mul::query(&c, &d); + let same_mul = m1.handle().eq(&m2.handle()); + #[eggplant::pat_vars] + struct Pat { + a: Expr, + b: Expr, + c: Expr, + d: Expr, + _m1: Mul, + _m2: Mul, + } + Pat::new(a, b, c, d, m1, m2).assert(same_mul) + }, + |ctx, pat| { + ctx.union(pat.a, pat.c); + ctx.union(pat.b, pat.d); + }, + ); + MyTxUnify::add_rule( + "lit_eq_mul_panic", + step, + || { + let a = Expr::query_leaf(); + let b = Expr::query_leaf(); + let lit = Lit::query(); + let mul = Mul::query(&a, &b); + let same_term = lit.handle().eq(&mul.handle()); + #[eggplant::pat_vars] + struct Pat { + a: Expr, + b: Expr, + _lit: Lit, + _mul: Mul, + } + Pat::new(a, b, lit, mul).assert(same_term) + }, + |_ctx, _pat| { + panic!("Literal cannot be equal to a product"); + }, + ); MyTxUnify::run_ruleset(seed, RunConfig::Once); MyTxUnify::run_ruleset(step, RunConfig::Times(3)); diff --git a/benches/runners/generated/eggcc_extraction.rs b/benches/runners/generated/eggcc_extraction.rs index 5872599..a18695d 100644 --- a/benches/runners/generated/eggcc_extraction.rs +++ b/benches/runners/generated/eggcc_extraction.rs @@ -39,34 +39,34 @@ struct EcxVecVecOperandBase { #[eggplant::dsl(container = EcxFuncSigs, container = EcxVecOperandBase, container = EcxVecVecOperandBase)] enum EcxBody { - #[eggplant::precedence(100)] - #[eggplant::typst("Gamma({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("Gamma({a0}, {a1}, {a2})")] EcxGamma { a0: EcxOperand, a1: EcxVecOperand, a2: EcxVecVecOperand, }, - #[eggplant::precedence(100)] - #[eggplant::typst("OperandGroup({a0})")] + #[precedence(100)] + #[typst("OperandGroup({a0})")] EcxOperandGroup { a0: EcxVecOperand }, - #[eggplant::precedence(100)] - #[eggplant::typst("PureOp({a0})")] + #[precedence(100)] + #[typst("PureOp({a0})")] EcxPureOp { a0: EcxExpr }, - #[eggplant::precedence(100)] - #[eggplant::typst("ShiftBody({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("ShiftBody({a0}, {a1}, {a2})")] EcxShiftBody { a0: EcxBody, a1: i64, a2: i64 }, - #[eggplant::precedence(100)] - #[eggplant::typst("SubstBody({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("SubstBody({a0}, {a1}, {a2})")] EcxSubstBody { a0: EcxBody, a1: i64, a2: EcxOperand, }, - #[eggplant::precedence(100)] - #[eggplant::typst("SubstBodyAll({a0}, {a1})")] + #[precedence(100)] + #[typst("SubstBodyAll({a0}, {a1})")] EcxSubstBodyAll { a0: EcxBody, a1: EcxVecOperand }, - #[eggplant::precedence(100)] - #[eggplant::typst("Theta({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("Theta({a0}, {a1}, {a2})")] EcxTheta { a0: EcxOperand, a1: EcxVecOperand, @@ -76,140 +76,140 @@ enum EcxBody { #[eggplant::dsl(container = EcxFuncSigs, container = EcxVecOperandBase, container = EcxVecVecOperandBase)] enum EcxConstOps { - #[eggplant::precedence(100)] - #[eggplant::typst("kw_const")] + #[precedence(100)] + #[typst("kw_const")] Ecxkw_const {}, } #[eggplant::dsl(container = EcxFuncSigs, container = EcxVecOperandBase, container = EcxVecVecOperandBase)] enum EcxEffectType { - #[eggplant::precedence(100)] - #[eggplant::typst("Bril({a0})")] + #[precedence(100)] + #[typst("Bril({a0})")] EcxBril { a0: EcxType }, - #[eggplant::precedence(100)] - #[eggplant::typst("PrintState")] + #[precedence(100)] + #[typst("PrintState")] EcxPrintState {}, } #[eggplant::dsl(container = EcxFuncSigs, container = EcxVecOperandBase, container = EcxVecVecOperandBase)] enum EcxExpr { - #[eggplant::precedence(100)] - #[eggplant::typst("Call({a0}, {a1}, {a2}, {a3})")] + #[precedence(100)] + #[typst("Call({a0}, {a1}, {a2}, {a3})")] EcxCall { a0: EcxOptionType, a1: String, a2: EcxVecOperand, a3: i64, }, - #[eggplant::precedence(100)] - #[eggplant::typst("Const({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("Const({a0}, {a1}, {a2})")] EcxConst { a0: EcxType, a1: EcxConstOps, a2: EcxLiteral, }, - #[eggplant::precedence(100)] - #[eggplant::typst("PRINT({a0}, {a1})")] + #[precedence(100)] + #[typst("PRINT({a0}, {a1})")] EcxPRINT { a0: EcxOperand, a1: EcxOperand }, - #[eggplant::precedence(100)] - #[eggplant::typst("ShiftExpr({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("ShiftExpr({a0}, {a1}, {a2})")] EcxShiftExpr { a0: EcxExpr, a1: i64, a2: i64 }, - #[eggplant::precedence(100)] - #[eggplant::typst("SubstExpr({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("SubstExpr({a0}, {a1}, {a2})")] EcxSubstExpr { a0: EcxExpr, a1: i64, a2: EcxOperand, }, - #[eggplant::precedence(100)] - #[eggplant::typst("SubstExprAll({a0}, {a1})")] + #[precedence(100)] + #[typst("SubstExprAll({a0}, {a1})")] EcxSubstExprAll { a0: EcxExpr, a1: EcxVecOperand }, - #[eggplant::precedence(100)] - #[eggplant::typst("badd({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("badd({a0}, {a1}, {a2})")] Ecxbadd { a0: EcxType, a1: EcxOperand, a2: EcxOperand, }, - #[eggplant::precedence(100)] - #[eggplant::typst("band({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("band({a0}, {a1}, {a2})")] Ecxband { a0: EcxType, a1: EcxOperand, a2: EcxOperand, }, - #[eggplant::precedence(100)] - #[eggplant::typst("bdiv({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("bdiv({a0}, {a1}, {a2})")] Ecxbdiv { a0: EcxType, a1: EcxOperand, a2: EcxOperand, }, - #[eggplant::precedence(100)] - #[eggplant::typst("beq({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("beq({a0}, {a1}, {a2})")] Ecxbeq { a0: EcxType, a1: EcxOperand, a2: EcxOperand, }, - #[eggplant::precedence(100)] - #[eggplant::typst("bfmul({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("bfmul({a0}, {a1}, {a2})")] Ecxbfmul { a0: EcxType, a1: EcxOperand, a2: EcxOperand, }, - #[eggplant::precedence(100)] - #[eggplant::typst("bge({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("bge({a0}, {a1}, {a2})")] Ecxbge { a0: EcxType, a1: EcxOperand, a2: EcxOperand, }, - #[eggplant::precedence(100)] - #[eggplant::typst("bgt({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("bgt({a0}, {a1}, {a2})")] Ecxbgt { a0: EcxType, a1: EcxOperand, a2: EcxOperand, }, - #[eggplant::precedence(100)] - #[eggplant::typst("ble({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("ble({a0}, {a1}, {a2})")] Ecxble { a0: EcxType, a1: EcxOperand, a2: EcxOperand, }, - #[eggplant::precedence(100)] - #[eggplant::typst("blt({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("blt({a0}, {a1}, {a2})")] Ecxblt { a0: EcxType, a1: EcxOperand, a2: EcxOperand, }, - #[eggplant::precedence(100)] - #[eggplant::typst("bmul({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("bmul({a0}, {a1}, {a2})")] Ecxbmul { a0: EcxType, a1: EcxOperand, a2: EcxOperand, }, - #[eggplant::precedence(100)] - #[eggplant::typst("bnot({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("bnot({a0}, {a1}, {a2})")] Ecxbnot { a0: EcxType, a1: EcxOperand, a2: EcxOperand, }, - #[eggplant::precedence(100)] - #[eggplant::typst("bor({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("bor({a0}, {a1}, {a2})")] Ecxbor { a0: EcxType, a1: EcxOperand, a2: EcxOperand, }, - #[eggplant::precedence(100)] - #[eggplant::typst("bsub({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("bsub({a0}, {a1}, {a2})")] Ecxbsub { a0: EcxType, a1: EcxOperand, @@ -219,8 +219,8 @@ enum EcxExpr { #[eggplant::dsl(container = EcxFuncSigs, container = EcxVecOperandBase, container = EcxVecVecOperandBase)] enum EcxFunction { - #[eggplant::precedence(100)] - #[eggplant::typst("Func({a0}, {a1}, {a2}, {a3})")] + #[precedence(100)] + #[typst("Func({a0}, {a1}, {a2}, {a3})")] EcxFunc { a0: String, a1: EcxFuncSigs, @@ -231,298 +231,298 @@ enum EcxFunction { #[eggplant::dsl(container = EcxFuncSigs, container = EcxVecOperandBase, container = EcxVecVecOperandBase)] enum EcxInterval { - #[eggplant::precedence(100)] - #[eggplant::typst("BoolI({a0}, {a1})")] + #[precedence(100)] + #[typst("BoolI({a0}, {a1})")] EcxBoolI { a0: bool, a1: bool }, - #[eggplant::precedence(100)] - #[eggplant::typst("IntI({a0}, {a1})")] + #[precedence(100)] + #[typst("IntI({a0}, {a1})")] EcxIntI { a0: i64, a1: i64 }, - #[eggplant::precedence(100)] - #[eggplant::typst("interval_intersect({a0}, {a1})")] + #[precedence(100)] + #[typst("interval_intersect({a0}, {a1})")] Ecxinterval_intersect { a0: EcxInterval, a1: EcxInterval }, - #[eggplant::precedence(100)] - #[eggplant::typst("interval_union({a0}, {a1})")] + #[precedence(100)] + #[typst("interval_union({a0}, {a1})")] Ecxinterval_union { a0: EcxInterval, a1: EcxInterval }, } #[eggplant::dsl(container = EcxFuncSigs, container = EcxVecOperandBase, container = EcxVecVecOperandBase)] enum EcxLiteral { - #[eggplant::precedence(100)] - #[eggplant::typst("Bool({a0})")] + #[precedence(100)] + #[typst("Bool({a0})")] EcxBool { a0: bool }, - #[eggplant::precedence(100)] - #[eggplant::typst("Char({a0})")] + #[precedence(100)] + #[typst("Char({a0})")] EcxChar { a0: String }, - #[eggplant::precedence(100)] - #[eggplant::typst("Float({a0})")] + #[precedence(100)] + #[typst("Float({a0})")] EcxFloat { a0: f64 }, - #[eggplant::precedence(100)] - #[eggplant::typst("Num({a0})")] + #[precedence(100)] + #[typst("Num({a0})")] EcxNum { a0: i64 }, } #[eggplant::dsl(container = EcxFuncSigs, container = EcxVecOperandBase, container = EcxVecVecOperandBase)] enum EcxOperand { - #[eggplant::precedence(100)] - #[eggplant::typst("Arg({a0})")] + #[precedence(100)] + #[typst("Arg({a0})")] EcxArg { a0: i64 }, - #[eggplant::precedence(100)] - #[eggplant::typst("Node({a0})")] + #[precedence(100)] + #[typst("Node({a0})")] EcxNode { a0: EcxBody }, - #[eggplant::precedence(100)] - #[eggplant::typst("Project({a0}, {a1})")] + #[precedence(100)] + #[typst("Project({a0}, {a1})")] EcxProject { a0: i64, a1: EcxBody }, - #[eggplant::precedence(100)] - #[eggplant::typst("ShiftOperand({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("ShiftOperand({a0}, {a1}, {a2})")] EcxShiftOperand { a0: EcxOperand, a1: i64, a2: i64 }, - #[eggplant::precedence(100)] - #[eggplant::typst("SubstOperand({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("SubstOperand({a0}, {a1}, {a2})")] EcxSubstOperand { a0: EcxOperand, a1: i64, a2: EcxOperand, }, - #[eggplant::precedence(100)] - #[eggplant::typst("SubstOperandAll({a0}, {a1})")] + #[precedence(100)] + #[typst("SubstOperandAll({a0}, {a1})")] EcxSubstOperandAll { a0: EcxOperand, a1: EcxVecOperand }, - #[eggplant::precedence(100)] - #[eggplant::typst("VecOperand_get({a0}, {a1})")] + #[precedence(100)] + #[typst("VecOperand_get({a0}, {a1})")] EcxVecOperand_get { a0: EcxVecOperand, a1: i64 }, } #[eggplant::dsl(container = EcxFuncSigs, container = EcxVecOperandBase, container = EcxVecVecOperandBase)] enum EcxOptionType { - #[eggplant::precedence(100)] - #[eggplant::typst("NoneType")] + #[precedence(100)] + #[typst("NoneType")] EcxNoneType {}, - #[eggplant::precedence(100)] - #[eggplant::typst("SomeType({a0})")] + #[precedence(100)] + #[typst("SomeType({a0})")] EcxSomeType { a0: EcxType }, } #[eggplant::dsl(container = EcxFuncSigs, container = EcxVecOperandBase, container = EcxVecVecOperandBase)] enum EcxTermAndCost { - #[eggplant::precedence(100)] - #[eggplant::typst("BodyAndCost({a0}, {a1})")] + #[precedence(100)] + #[typst("BodyAndCost({a0}, {a1})")] EcxBodyAndCost { a0: EcxBody, a1: i64 }, - #[eggplant::precedence(100)] - #[eggplant::typst("ExprAndCost({a0}, {a1})")] + #[precedence(100)] + #[typst("ExprAndCost({a0}, {a1})")] EcxExprAndCost { a0: EcxExpr, a1: i64 }, - #[eggplant::precedence(100)] - #[eggplant::typst("OperandAndCost({a0}, {a1})")] + #[precedence(100)] + #[typst("OperandAndCost({a0}, {a1})")] EcxOperandAndCost { a0: EcxOperand, a1: i64 }, - #[eggplant::precedence(100)] - #[eggplant::typst("Smaller({a0}, {a1})")] + #[precedence(100)] + #[typst("Smaller({a0}, {a1})")] EcxSmaller { a0: EcxTermAndCost, a1: EcxTermAndCost, }, - #[eggplant::precedence(100)] - #[eggplant::typst("VecOperandAndCost({a0}, {a1})")] + #[precedence(100)] + #[typst("VecOperandAndCost({a0}, {a1})")] EcxVecOperandAndCost { a0: EcxVecOperand, a1: i64 }, - #[eggplant::precedence(100)] - #[eggplant::typst("VecVecOperandAndCost({a0}, {a1})")] + #[precedence(100)] + #[typst("VecVecOperandAndCost({a0}, {a1})")] EcxVecVecOperandAndCost { a0: EcxVecVecOperand, a1: i64 }, } #[eggplant::dsl(container = EcxFuncSigs, container = EcxVecOperandBase, container = EcxVecVecOperandBase)] enum EcxType { - #[eggplant::precedence(100)] - #[eggplant::typst("BoolT")] + #[precedence(100)] + #[typst("BoolT")] EcxBoolT {}, - #[eggplant::precedence(100)] - #[eggplant::typst("CharT")] + #[precedence(100)] + #[typst("CharT")] EcxCharT {}, - #[eggplant::precedence(100)] - #[eggplant::typst("FloatT")] + #[precedence(100)] + #[typst("FloatT")] EcxFloatT {}, - #[eggplant::precedence(100)] - #[eggplant::typst("IntT")] + #[precedence(100)] + #[typst("IntT")] EcxIntT {}, - #[eggplant::precedence(100)] - #[eggplant::typst("PointerT({a0})")] + #[precedence(100)] + #[typst("PointerT({a0})")] EcxPointerT { a0: EcxType }, } #[eggplant::dsl(container = EcxFuncSigs, container = EcxVecOperandBase, container = EcxVecVecOperandBase)] enum EcxVecOperand { - #[eggplant::precedence(100)] - #[eggplant::typst("BodyToVecOperand({a0}, {a1})")] + #[precedence(100)] + #[typst("BodyToVecOperand({a0}, {a1})")] EcxBodyToVecOperand { a0: i64, a1: EcxBody }, - #[eggplant::precedence(100)] - #[eggplant::typst("BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})")] + #[precedence(100)] + #[typst("BodyToVecOperandHelper({a0}, {a1}, {a2}, {a3})")] EcxBodyToVecOperandHelper { a0: i64, a1: i64, a2: EcxBody, a3: EcxVecOperandBase, }, - #[eggplant::precedence(100)] - #[eggplant::typst("PassThroughArguments({a0})")] + #[precedence(100)] + #[typst("PassThroughArguments({a0})")] EcxPassThroughArguments { a0: i64 }, - #[eggplant::precedence(100)] - #[eggplant::typst("PassThroughArgumentsHelper({a0}, {a1})")] + #[precedence(100)] + #[typst("PassThroughArgumentsHelper({a0}, {a1})")] EcxPassThroughArgumentsHelper { a0: i64, a1: EcxVecOperand }, - #[eggplant::precedence(100)] - #[eggplant::typst("ShiftVecOperand({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("ShiftVecOperand({a0}, {a1}, {a2})")] EcxShiftVecOperand { a0: EcxVecOperand, a1: i64, a2: i64 }, - #[eggplant::precedence(100)] - #[eggplant::typst("ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})")] + #[precedence(100)] + #[typst("ShiftVecOperand_helper({a0}, {a1}, {a2}, {a3})")] EcxShiftVecOperand_helper { a0: EcxVecOperand, a1: i64, a2: i64, a3: i64, }, - #[eggplant::precedence(100)] - #[eggplant::typst("SubstVecOperand({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("SubstVecOperand({a0}, {a1}, {a2})")] EcxSubstVecOperand { a0: EcxVecOperand, a1: i64, a2: EcxOperand, }, - #[eggplant::precedence(100)] - #[eggplant::typst("SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})")] + #[precedence(100)] + #[typst("SubstVecOperand_helper({a0}, {a1}, {a2}, {a3})")] EcxSubstVecOperand_helper { a0: EcxVecOperand, a1: i64, a2: EcxOperand, a3: i64, }, - #[eggplant::precedence(100)] - #[eggplant::typst("SubstVecOperandAll({a0}, {a1})")] + #[precedence(100)] + #[typst("SubstVecOperandAll({a0}, {a1})")] EcxSubstVecOperandAll { a0: EcxVecOperand, a1: EcxVecOperand, }, - #[eggplant::precedence(100)] - #[eggplant::typst("SubstVecOperandAll_helper({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("SubstVecOperandAll_helper({a0}, {a1}, {a2})")] EcxSubstVecOperandAll_helper { a0: EcxVecOperand, a1: EcxVecOperand, a2: i64, }, - #[eggplant::precedence(100)] - #[eggplant::typst("VO({a0})")] + #[precedence(100)] + #[typst("VO({a0})")] EcxVO { a0: EcxVecOperandBase }, - #[eggplant::precedence(100)] - #[eggplant::typst("VecVecOperand_get({a0}, {a1})")] + #[precedence(100)] + #[typst("VecVecOperand_get({a0}, {a1})")] EcxVecVecOperand_get { a0: EcxVecVecOperand, a1: i64 }, } #[eggplant::dsl(container = EcxFuncSigs, container = EcxVecOperandBase, container = EcxVecVecOperandBase)] enum EcxVecVecOperand { - #[eggplant::precedence(100)] - #[eggplant::typst("ShiftVecVecOperand({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("ShiftVecVecOperand({a0}, {a1}, {a2})")] EcxShiftVecVecOperand { a0: EcxVecVecOperand, a1: i64, a2: i64, }, - #[eggplant::precedence(100)] - #[eggplant::typst("ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})")] + #[precedence(100)] + #[typst("ShiftVecVecOperand_helper({a0}, {a1}, {a2}, {a3})")] EcxShiftVecVecOperand_helper { a0: EcxVecVecOperand, a1: i64, a2: i64, a3: i64, }, - #[eggplant::precedence(100)] - #[eggplant::typst("SubstVecVecOperand({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("SubstVecVecOperand({a0}, {a1}, {a2})")] EcxSubstVecVecOperand { a0: EcxVecVecOperand, a1: i64, a2: EcxOperand, }, - #[eggplant::precedence(100)] - #[eggplant::typst("SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})")] + #[precedence(100)] + #[typst("SubstVecVecOperand_helper({a0}, {a1}, {a2}, {a3})")] EcxSubstVecVecOperand_helper { a0: EcxVecVecOperand, a1: i64, a2: EcxOperand, a3: i64, }, - #[eggplant::precedence(100)] - #[eggplant::typst("SubstVecVecOperandAll({a0}, {a1})")] + #[precedence(100)] + #[typst("SubstVecVecOperandAll({a0}, {a1})")] EcxSubstVecVecOperandAll { a0: EcxVecVecOperand, a1: EcxVecOperand, }, - #[eggplant::precedence(100)] - #[eggplant::typst("SubstVecVecOperandAll_helper({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("SubstVecVecOperandAll_helper({a0}, {a1}, {a2})")] EcxSubstVecVecOperandAll_helper { a0: EcxVecVecOperand, a1: EcxVecOperand, a2: i64, }, - #[eggplant::precedence(100)] - #[eggplant::typst("VVO({a0})")] + #[precedence(100)] + #[typst("VVO({a0})")] EcxVVO { a0: EcxVecVecOperandBase }, } #[eggplant::dsl(container = EcxFuncSigs, container = EcxVecOperandBase, container = EcxVecVecOperandBase)] enum EcxRel { - #[eggplant::precedence(100)] - #[eggplant::typst("Body_contains_Body({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("Body_contains_Body({a0}, {a1}, {a2})")] EcxBody_contains_Body { a0: EcxBody, a1: i64, a2: EcxBody }, - #[eggplant::precedence(100)] - #[eggplant::typst("Body_contains_Expr({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("Body_contains_Expr({a0}, {a1}, {a2})")] EcxBody_contains_Expr { a0: EcxBody, a1: i64, a2: EcxExpr }, - #[eggplant::precedence(100)] - #[eggplant::typst("Body_contains_Operand({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("Body_contains_Operand({a0}, {a1}, {a2})")] EcxBody_contains_Operand { a0: EcxBody, a1: i64, a2: EcxOperand, }, - #[eggplant::precedence(100)] - #[eggplant::typst("Body_is_pure({a0})")] + #[precedence(100)] + #[typst("Body_is_pure({a0})")] EcxBody_is_pure { a0: EcxBody }, - #[eggplant::precedence(100)] - #[eggplant::typst("Expr_is_pure({a0})")] + #[precedence(100)] + #[typst("Expr_is_pure({a0})")] EcxExpr_is_pure { a0: EcxExpr }, - #[eggplant::precedence(100)] - #[eggplant::typst("Function_is_pure({a0})")] + #[precedence(100)] + #[typst("Function_is_pure({a0})")] EcxFunction_is_pure { a0: EcxFunction }, - #[eggplant::precedence(100)] - #[eggplant::typst("Operand_is_pure({a0})")] + #[precedence(100)] + #[typst("Operand_is_pure({a0})")] EcxOperand_is_pure { a0: EcxOperand }, - #[eggplant::precedence(100)] - #[eggplant::typst("VecOperand_is_pure({a0})")] + #[precedence(100)] + #[typst("VecOperand_is_pure({a0})")] EcxVecOperand_is_pure { a0: EcxVecOperand }, - #[eggplant::precedence(100)] - #[eggplant::typst("VecVecOperand_is_pure({a0})")] + #[precedence(100)] + #[typst("VecVecOperand_is_pure({a0})")] EcxVecVecOperand_is_pure { a0: EcxVecVecOperand }, - #[eggplant::precedence(100)] - #[eggplant::typst("can_subst_Body_beneath({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("can_subst_Body_beneath({a0}, {a1}, {a2})")] Ecxcan_subst_Body_beneath { a0: EcxBody, a1: EcxBody, a2: EcxBody, }, - #[eggplant::precedence(100)] - #[eggplant::typst("can_subst_Expr_beneath({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("can_subst_Expr_beneath({a0}, {a1}, {a2})")] Ecxcan_subst_Expr_beneath { a0: EcxBody, a1: EcxExpr, a2: EcxExpr, }, - #[eggplant::precedence(100)] - #[eggplant::typst("can_subst_Operand_beneath({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("can_subst_Operand_beneath({a0}, {a1}, {a2})")] Ecxcan_subst_Operand_beneath { a0: EcxBody, a1: EcxOperand, a2: EcxOperand, }, - #[eggplant::precedence(100)] - #[eggplant::typst("can_subst_VecOperand_beneath({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("can_subst_VecOperand_beneath({a0}, {a1}, {a2})")] Ecxcan_subst_VecOperand_beneath { a0: EcxBody, a1: EcxVecOperand, a2: EcxVecOperand, }, - #[eggplant::precedence(100)] - #[eggplant::typst("can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("can_subst_VecVecOperand_beneath({a0}, {a1}, {a2})")] Ecxcan_subst_VecVecOperand_beneath { a0: EcxBody, a1: EcxVecVecOperand, diff --git a/benches/runners/generated/extract_vec_bench.rs b/benches/runners/generated/extract_vec_bench.rs index 5b2ed76..a44b8bc 100644 --- a/benches/runners/generated/extract_vec_bench.rs +++ b/benches/runners/generated/extract_vec_bench.rs @@ -11,151 +11,151 @@ struct Vec_Tensor { #[eggplant::dsl] enum IntTuple { - #[eggplant::precedence(100)] - #[eggplant::typst("IntTuple___add__({a0}, {a1})")] + #[precedence(100)] + #[typst("IntTuple___add__({a0}, {a1})")] IntTuple___add__ { a0: IntTuple, a1: IntTuple }, - #[eggplant::precedence(100)] - #[eggplant::typst("IntTuple___init__({a0})")] + #[precedence(100)] + #[typst("IntTuple___init__({a0})")] IntTuple___init__ { a0: Int }, } #[eggplant::dsl] enum Int { - #[eggplant::precedence(100)] - #[eggplant::typst("Int___init__({a0})")] + #[precedence(100)] + #[typst("Int___init__({a0})")] Int___init__ { a0: i64 }, - #[eggplant::precedence(100)] - #[eggplant::typst("Int_var({a0})")] + #[precedence(100)] + #[typst("Int_var({a0})")] Int_var { a0: String }, } #[eggplant::dsl] enum StringTensor { - #[eggplant::precedence(100)] - #[eggplant::typst("StringTensor___init__({a0})")] + #[precedence(100)] + #[typst("StringTensor___init__({a0})")] StringTensor___init__ { a0: String }, } #[eggplant::dsl] enum FloatTuple { - #[eggplant::precedence(100)] - #[eggplant::typst("FloatTuple___init__({a0})")] + #[precedence(100)] + #[typst("FloatTuple___init__({a0})")] FloatTuple___init__ { a0: Float }, - #[eggplant::precedence(100)] - #[eggplant::typst("FloatTuple___add__({a0}, {a1})")] + #[precedence(100)] + #[typst("FloatTuple___add__({a0}, {a1})")] FloatTuple___add__ { a0: FloatTuple, a1: FloatTuple }, } #[eggplant::dsl] enum Float { - #[eggplant::precedence(100)] - #[eggplant::typst("Float_var({a0})")] + #[precedence(100)] + #[typst("Float_var({a0})")] Float_var { a0: String }, - #[eggplant::precedence(100)] - #[eggplant::typst("Float___init__({a0})")] + #[precedence(100)] + #[typst("Float___init__({a0})")] Float___init__ { a0: f64 }, } #[eggplant::dsl] enum Tensor { - #[eggplant::precedence(100)] - #[eggplant::typst("UnaryOp___call__({a0}, {a1})")] + #[precedence(100)] + #[typst("UnaryOp___call__({a0}, {a1})")] UnaryOp___call__ { a0: UnaryOp, a1: Tensor }, - #[eggplant::precedence(100)] - #[eggplant::typst("BinaryOp___call__({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("BinaryOp___call__({a0}, {a1}, {a2})")] BinaryOp___call__ { a0: BinaryOp, a1: Tensor, a2: Tensor, }, - #[eggplant::precedence(100)] - #[eggplant::typst("Tensor___init__({a0}, {a1}, {a2}, {a3})")] + #[precedence(100)] + #[typst("Tensor___init__({a0}, {a1}, {a2}, {a3})")] Tensor___init__ { a0: StringTensor, a1: IntTuple, a2: StringTensor, a3: FloatTuple, }, - #[eggplant::precedence(100)] - #[eggplant::typst("Constant_tensor({a0})")] + #[precedence(100)] + #[typst("Constant_tensor({a0})")] Constant_tensor { a0: Constant }, - #[eggplant::precedence(100)] - #[eggplant::typst("Iota_tensor({a0})")] + #[precedence(100)] + #[typst("Iota_tensor({a0})")] Iota_tensor { a0: Iota }, - #[eggplant::precedence(100)] - #[eggplant::typst("NaryOp___call__({a0}, {a1})")] + #[precedence(100)] + #[typst("NaryOp___call__({a0}, {a1})")] NaryOp___call__ { a0: NaryOp, a1: TensorArr }, } #[eggplant::dsl] enum UnaryOp { - #[eggplant::precedence(100)] - #[eggplant::typst("cosine_xla({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("cosine_xla({a0}, {a1}, {a2})")] cosine_xla { a0: IntTuple, a1: StringTensor, a2: StringTensor, }, - #[eggplant::precedence(100)] - #[eggplant::typst("reshape({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("reshape({a0}, {a1}, {a2})")] reshape { a0: IntTuple, a1: StringTensor, a2: StringTensor, }, - #[eggplant::precedence(100)] - #[eggplant::typst("convert_xla({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("convert_xla({a0}, {a1}, {a2})")] convert_xla { a0: IntTuple, a1: StringTensor, a2: StringTensor, }, - #[eggplant::precedence(100)] - #[eggplant::typst("custom_call({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("custom_call({a0}, {a1}, {a2})")] custom_call { a0: IntTuple, a1: StringTensor, a2: StringTensor, }, - #[eggplant::precedence(100)] - #[eggplant::typst("slice_xla({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("slice_xla({a0}, {a1}, {a2})")] slice_xla { a0: IntTuple, a1: StringTensor, a2: StringTensor, }, - #[eggplant::precedence(100)] - #[eggplant::typst("broadcast({a0}, {a1}, {a2}, {a3})")] + #[precedence(100)] + #[typst("broadcast({a0}, {a1}, {a2}, {a3})")] broadcast { a0: IntTuple, a1: StringTensor, a2: StringTensor, a3: IntTuple, }, - #[eggplant::precedence(100)] - #[eggplant::typst("sine_xla({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("sine_xla({a0}, {a1}, {a2})")] sine_xla { a0: IntTuple, a1: StringTensor, a2: StringTensor, }, - #[eggplant::precedence(100)] - #[eggplant::typst("exp_xla({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("exp_xla({a0}, {a1}, {a2})")] exp_xla { a0: IntTuple, a1: StringTensor, a2: StringTensor, }, - #[eggplant::precedence(100)] - #[eggplant::typst("transpose({a0}, {a1}, {a2}, {a3})")] + #[precedence(100)] + #[typst("transpose({a0}, {a1}, {a2}, {a3})")] transpose { a0: IntTuple, a1: StringTensor, a2: StringTensor, a3: IntTuple, }, - #[eggplant::precedence(100)] - #[eggplant::typst("log_xla({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("log_xla({a0}, {a1}, {a2})")] log_xla { a0: IntTuple, a1: StringTensor, @@ -165,57 +165,57 @@ enum UnaryOp { #[eggplant::dsl] enum BinaryOp { - #[eggplant::precedence(100)] - #[eggplant::typst("dot_xla({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("dot_xla({a0}, {a1}, {a2})")] dot_xla { a0: IntTuple, a1: StringTensor, a2: StringTensor, }, - #[eggplant::precedence(100)] - #[eggplant::typst("and_xla({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("and_xla({a0}, {a1}, {a2})")] and_xla { a0: IntTuple, a1: StringTensor, a2: StringTensor, }, - #[eggplant::precedence(100)] - #[eggplant::typst("compare({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("compare({a0}, {a1}, {a2})")] compare { a0: IntTuple, a1: StringTensor, a2: StringTensor, }, - #[eggplant::precedence(100)] - #[eggplant::typst("divide({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("divide({a0}, {a1}, {a2})")] divide { a0: IntTuple, a1: StringTensor, a2: StringTensor, }, - #[eggplant::precedence(100)] - #[eggplant::typst("subtract_xla({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("subtract_xla({a0}, {a1}, {a2})")] subtract_xla { a0: IntTuple, a1: StringTensor, a2: StringTensor, }, - #[eggplant::precedence(100)] - #[eggplant::typst("multiply({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("multiply({a0}, {a1}, {a2})")] multiply { a0: IntTuple, a1: StringTensor, a2: StringTensor, }, - #[eggplant::precedence(100)] - #[eggplant::typst("add_xla({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("add_xla({a0}, {a1}, {a2})")] add_xla { a0: IntTuple, a1: StringTensor, a2: StringTensor, }, - #[eggplant::precedence(100)] - #[eggplant::typst("maximum_xla({a0}, {a1}, {a2})")] + #[precedence(100)] + #[typst("maximum_xla({a0}, {a1}, {a2})")] maximum_xla { a0: IntTuple, a1: StringTensor, @@ -225,38 +225,38 @@ enum BinaryOp { #[eggplant::dsl] enum Constant { - #[eggplant::precedence(100)] - #[eggplant::typst("Constant___init__({a0})")] + #[precedence(100)] + #[typst("Constant___init__({a0})")] Constant___init__ { a0: Tensor }, } #[eggplant::dsl] enum Iota { - #[eggplant::precedence(100)] - #[eggplant::typst("Iota___init__({a0})")] + #[precedence(100)] + #[typst("Iota___init__({a0})")] Iota___init__ { a0: Tensor }, } #[eggplant::dsl] enum NaryOp { - #[eggplant::precedence(100)] - #[eggplant::typst("select({a0}, {a1}, {a2}, {a3})")] + #[precedence(100)] + #[typst("select({a0}, {a1}, {a2}, {a3})")] select { a0: Int, a1: IntTuple, a2: StringTensor, a3: StringTensor, }, - #[eggplant::precedence(100)] - #[eggplant::typst("concatenate({a0}, {a1}, {a2}, {a3})")] + #[precedence(100)] + #[typst("concatenate({a0}, {a1}, {a2}, {a3})")] concatenate { a0: Int, a1: IntTuple, a2: StringTensor, a3: StringTensor, }, - #[eggplant::precedence(100)] - #[eggplant::typst("reduce({a0}, {a1}, {a2}, {a3}, {a4})")] + #[precedence(100)] + #[typst("reduce({a0}, {a1}, {a2}, {a3}, {a4})")] reduce { a0: OpType, a1: Int, @@ -264,8 +264,8 @@ enum NaryOp { a3: StringTensor, a4: StringTensor, }, - #[eggplant::precedence(100)] - #[eggplant::typst("scatter_xla({a0}, {a1}, {a2}, {a3})")] + #[precedence(100)] + #[typst("scatter_xla({a0}, {a1}, {a2}, {a3})")] scatter_xla { a0: Int, a1: IntTuple, @@ -276,15 +276,15 @@ enum NaryOp { #[eggplant::dsl] enum TensorArr { - #[eggplant::precedence(100)] - #[eggplant::typst("TensorArr___init__({a0})")] + #[precedence(100)] + #[typst("TensorArr___init__({a0})")] TensorArr___init__ { a0: Vec_Tensor }, } #[eggplant::dsl] enum OpType { - #[eggplant::precedence(100)] - #[eggplant::typst("AddOp")] + #[precedence(100)] + #[typst("AddOp")] AddOp {}, } diff --git a/benches/runners/generated/taylor51.rs b/benches/runners/generated/taylor51.rs index 2b5ca0e..2612dd1 100644 --- a/benches/runners/generated/taylor51.rs +++ b/benches/runners/generated/taylor51.rs @@ -5,87 +5,87 @@ use eggplant::prelude::*; #[eggplant::dsl] enum M { - #[eggplant::typst("{a0}")] - #[eggplant::precedence(100)] + #[typst("{a0}")] + #[precedence(100)] T51Var { a0: String }, - #[eggplant::typst("{a0}")] - #[eggplant::precedence(100)] + #[typst("{a0}")] + #[precedence(100)] T51Num { a0: String }, - #[eggplant::typst("pi")] - #[eggplant::precedence(100)] + #[typst("pi")] + #[precedence(100)] T51Pi {}, - #[eggplant::typst("-({a0})")] - #[eggplant::precedence(70)] + #[typst("-({a0})")] + #[precedence(70)] T51Neg { a0: M }, - #[eggplant::typst("sin({a0})")] - #[eggplant::precedence(90)] + #[typst("sin({a0})")] + #[precedence(90)] T51Sin { a0: M }, - #[eggplant::typst("cos({a0})")] - #[eggplant::precedence(90)] + #[typst("cos({a0})")] + #[precedence(90)] T51Cos { a0: M }, - #[eggplant::typst("acos({a0})")] - #[eggplant::precedence(90)] + #[typst("acos({a0})")] + #[precedence(90)] T51Acos { a0: M }, - #[eggplant::typst("({a0}) + ({a1})")] - #[eggplant::precedence(50)] + #[typst("({a0}) + ({a1})")] + #[precedence(50)] T51Add { a0: M, a1: M }, - #[eggplant::typst("({a0}) - ({a1})")] - #[eggplant::precedence(50)] + #[typst("({a0}) - ({a1})")] + #[precedence(50)] T51Sub { a0: M, a1: M }, - #[eggplant::typst("({a0}) * ({a1})")] - #[eggplant::precedence(60)] + #[typst("({a0}) * ({a1})")] + #[precedence(60)] T51Mul { a0: M, a1: M }, - #[eggplant::typst("frac({a0}, {a1})")] - #[eggplant::precedence(60)] + #[typst("frac({a0}, {a1})")] + #[precedence(60)] T51Div { a0: M, a1: M }, - #[eggplant::typst("({a0})^({a1})")] - #[eggplant::precedence(80)] + #[typst("({a0})^({a1})")] + #[precedence(80)] T51Pow { a0: M, a1: M }, } #[eggplant::dsl] enum MTy { - #[eggplant::typst("{a0}")] - #[eggplant::precedence(100)] + #[typst("{a0}")] + #[precedence(100)] T51Varbinary64 { a0: String }, - #[eggplant::typst("{a0}")] - #[eggplant::precedence(100)] + #[typst("{a0}")] + #[precedence(100)] T51Numbinary64 { a0: String }, - #[eggplant::typst("pi")] - #[eggplant::precedence(100)] + #[typst("pi")] + #[precedence(100)] T51Pif64Ty {}, - #[eggplant::typst("-({a0})")] - #[eggplant::precedence(70)] + #[typst("-({a0})")] + #[precedence(70)] T51Negf64Ty { a0: MTy }, - #[eggplant::typst("sin({a0})")] - #[eggplant::precedence(90)] + #[typst("sin({a0})")] + #[precedence(90)] T51Sinf64Ty { a0: MTy }, - #[eggplant::typst("cos({a0})")] - #[eggplant::precedence(90)] + #[typst("cos({a0})")] + #[precedence(90)] T51Cosf64Ty { a0: MTy }, - #[eggplant::typst("acos({a0})")] - #[eggplant::precedence(90)] + #[typst("acos({a0})")] + #[precedence(90)] T51Acosf64Ty { a0: MTy }, - #[eggplant::typst("({a0}) + ({a1})")] - #[eggplant::precedence(50)] + #[typst("({a0}) + ({a1})")] + #[precedence(50)] T51Addf64Ty { a0: MTy, a1: MTy }, - #[eggplant::typst("({a0}) - ({a1})")] - #[eggplant::precedence(50)] + #[typst("({a0}) - ({a1})")] + #[precedence(50)] T51Subf64Ty { a0: MTy, a1: MTy }, - #[eggplant::typst("({a0}) * ({a1})")] - #[eggplant::precedence(60)] + #[typst("({a0}) * ({a1})")] + #[precedence(60)] T51Mulf64Ty { a0: MTy, a1: MTy }, - #[eggplant::typst("frac({a0}, {a1})")] - #[eggplant::precedence(60)] + #[typst("frac({a0}, {a1})")] + #[precedence(60)] T51Divf64Ty { a0: MTy, a1: MTy }, - #[eggplant::typst("({a0})^({a1})")] - #[eggplant::precedence(80)] + #[typst("({a0})^({a1})")] + #[precedence(80)] T51Powf64Ty { a0: MTy, a1: MTy }, - #[eggplant::typst("lower({a0}, {a1})")] - #[eggplant::precedence(90)] + #[typst("lower({a0}, {a1})")] + #[precedence(90)] T51Lower { a0: M, a1: String }, - #[eggplant::typst("approx({a0}, {a1})")] - #[eggplant::precedence(90)] + #[typst("approx({a0}, {a1})")] + #[precedence(90)] T51Approx { a0: M, a1: MTy }, } diff --git a/examples/_math_microbench_compare.rs b/examples/_math_microbench_compare.rs index 6e9907b..413be2d 100644 --- a/examples/_math_microbench_compare.rs +++ b/examples/_math_microbench_compare.rs @@ -22,8 +22,8 @@ fn print_stats(label: &str, stats: &MathMicrobenchmarkStats) { } fn collect_egg_stats() -> MathMicrobenchmarkStats { - let egglog_repo_root = - std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../stable/egglog_sync_serialize_raw"); + let egglog_repo_root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("../stable/egglog_sync_serialize_raw"); let filename = egglog_repo_root.join("tests/math-microbenchmark.egg"); let tables = [ ("Diff", "Diff"), diff --git a/examples/_math_microbench_compare_5.rs b/examples/_math_microbench_compare_5.rs new file mode 100644 index 0000000..21fef5d --- /dev/null +++ b/examples/_math_microbench_compare_5.rs @@ -0,0 +1,156 @@ +#[path = "math_microbenchmark_support.rs"] +mod math_microbenchmark_support; +#[path = "../benches/runners/eggplant_rewrite/math_microbenchmark.rs"] +mod typed_math_microbenchmark; + +use std::time::{Duration, Instant}; + +use egglog::EGraph; + +struct MathMicrobenchmarkStats { + elapsed: Duration, + total_num_tuples: usize, + table_sizes: Vec<(&'static str, usize)>, +} + +const TYPED_TABLES: &[&str] = &[ + "MDiff", + "MIntegral", + "MAdd", + "MSub", + "MMul", + "MDiv", + "MPow", + "MLn", + "MSqrt", + "MSin", + "MCos", + "MConst", + "MVar", +]; + +fn print_stats(label: &str, stats: &MathMicrobenchmarkStats) { + println!("{label} time: {:?}", stats.elapsed); + println!("[{label}] total num_tuples = {}", stats.total_num_tuples); + for (display, size) in &stats.table_sizes { + println!("[{label}] {display} = {size}"); + } +} + +fn collect_egg_stats() -> MathMicrobenchmarkStats { + let egglog_repo_root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("../stable/egglog_sync_serialize_raw"); + let filename = egglog_repo_root.join("tests/math-microbenchmark.egg"); + let tables = [ + ("Diff", "Diff"), + ("Integral", "Integral"), + ("Add", "Add"), + ("Sub", "Sub"), + ("Mul", "Mul"), + ("Div", "Div"), + ("Pow", "Pow"), + ("Ln", "Ln"), + ("Sqrt", "Sqrt"), + ("Sin", "Sin"), + ("Cos", "Cos"), + ("Const", "Const"), + ("Var", "Var"), + ]; + let mut egg = EGraph::default(); + let program = std::fs::read_to_string(&filename).unwrap(); + let started = Instant::now(); + egg.parse_and_run_program(Some(filename.to_string_lossy().into_owned()), &program) + .unwrap(); + + MathMicrobenchmarkStats { + elapsed: started.elapsed(), + total_num_tuples: egg.num_tuples(), + table_sizes: tables + .iter() + .map(|(display, table)| (*display, egg.get_size(table))) + .collect(), + } +} + +fn relabel_stats( + stats: Vec<(&'static str, usize)>, + relabel: &[(&'static str, &'static str)], +) -> Vec<(&'static str, usize)> { + relabel + .iter() + .map(|(display, source)| { + let size = stats + .iter() + .find_map(|(name, size)| (*name == *source).then_some(*size)) + .unwrap(); + (*display, size) + }) + .collect() +} + +fn collect_rust_rule_stats() -> MathMicrobenchmarkStats { + let mut input = math_microbenchmark_support::math_microbenchmark_setup(); + let started = Instant::now(); + math_microbenchmark_support::run_math_microbenchmark_iters(&mut input, 5); + MathMicrobenchmarkStats { + elapsed: started.elapsed(), + total_num_tuples: input.egraph.num_tuples(), + table_sizes: relabel_stats( + TYPED_TABLES + .iter() + .map(|table| (*table, input.egraph.get_size(table))) + .collect(), + &[ + ("Diff", "MDiff"), + ("Integral", "MIntegral"), + ("Add", "MAdd"), + ("Sub", "MSub"), + ("Mul", "MMul"), + ("Div", "MDiv"), + ("Pow", "MPow"), + ("Ln", "MLn"), + ("Sqrt", "MSqrt"), + ("Sin", "MSin"), + ("Cos", "MCos"), + ("Const", "MConst"), + ("Var", "MVar"), + ], + ), + } +} + +fn collect_typed_stats() -> MathMicrobenchmarkStats { + let stats = typed_math_microbenchmark::run_and_collect_stats_iters(false, 5); + MathMicrobenchmarkStats { + elapsed: stats.elapsed, + total_num_tuples: stats.total_num_tuples, + table_sizes: relabel_stats( + stats.table_sizes, + &[ + ("Diff", "MDiff"), + ("Integral", "MIntegral"), + ("Add", "MAdd"), + ("Sub", "MSub"), + ("Mul", "MMul"), + ("Div", "MDiv"), + ("Pow", "MPow"), + ("Ln", "MLn"), + ("Sqrt", "MSqrt"), + ("Sin", "MSin"), + ("Cos", "MCos"), + ("Const", "MConst"), + ("Var", "MVar"), + ], + ), + } +} + +fn main() { + let egg = collect_egg_stats(); + let rust = collect_rust_rule_stats(); + let typed = collect_typed_stats(); + + print_stats("egg", &egg); + print_stats("rust-5", &rust); + print_stats("typed-5", &typed); +} diff --git a/examples/math_microbenchmark_extract_bench.rs b/examples/math_microbenchmark_extract_bench.rs new file mode 100644 index 0000000..4426028 --- /dev/null +++ b/examples/math_microbenchmark_extract_bench.rs @@ -0,0 +1,132 @@ +#[cfg(not(feature = "rustsat-extract"))] +fn main() { + eprintln!("math_microbenchmark_extract_bench requires --features rustsat-extract"); +} + +#[path = "../benches/runners/eggplant_rewrite/math_microbenchmark.rs"] +mod typed_math_microbenchmark; + +#[cfg(feature = "rustsat-extract")] +mod real { + use super::typed_math_microbenchmark; + use std::time::Duration; + + pub struct CliArgs { + pub rewrite_iters: usize, + pub max_rewrite_mem_gib: u64, + } + + pub fn parse_args(args: I) -> CliArgs + where + I: IntoIterator, + S: AsRef, + { + let mut rewrite_iters = 11usize; + let mut max_rewrite_mem_gib = 20u64; + let mut it = args.into_iter().map(|arg| arg.as_ref().to_string()); + let _program = it.next(); + while let Some(arg) = it.next() { + match arg.as_str() { + "--max_iter" => { + let value = it + .next() + .unwrap_or_else(|| panic!("missing value for --max_iter")); + rewrite_iters = value + .parse::() + .unwrap_or_else(|_| panic!("invalid usize for --max_iter: {value}")); + } + "--max_mem" => { + let value = it + .next() + .unwrap_or_else(|| panic!("missing value for --max_mem")); + max_rewrite_mem_gib = value + .parse::() + .unwrap_or_else(|_| panic!("invalid u64 for --max_mem: {value}")); + } + other => panic!("unknown argument: {other}"), + } + } + CliArgs { + rewrite_iters, + max_rewrite_mem_gib, + } + } + + fn format_duration(duration: Duration) -> String { + format!("{:.3} ms", duration.as_secs_f64() * 1000.0) + } + + fn format_bytes(bytes: u64) -> String { + format!("{:.2} MiB", bytes as f64 / (1024.0 * 1024.0)) + } + + pub fn main() -> Result<(), Box> { + let _ = env_logger::try_init(); + let args = parse_args(std::env::args()); + + println!("CPU-style DSL costs used for Math:"); + println!("| Op | Cost |"); + println!("| --- | ---: |"); + println!("| MAdd | 1 |"); + println!("| MSub | 1 |"); + println!("| MMul | 3 |"); + println!("| MDiv | 10 |"); + println!("| MPow | 25 |"); + println!("| MLn | 18 |"); + println!("| MSqrt | 16 |"); + println!("| MSin | 18 |"); + println!("| MCos | 18 |"); + println!("| MDiff | 32 |"); + println!("| MIntegral | 40 |"); + println!("| MConst | 0 |"); + println!("| MVar | 0 |"); + println!(); + + println!("Target root:"); + println!("`Div(1, Sub(Div(Add(1, Sqrt(five)), 2), Div(Sub(1, Sqrt(five)), 2)))`"); + println!(); + + println!("Requested rewrite iterations: {}", args.rewrite_iters); + println!("Run ruleset memory cap: {} GiB", args.max_rewrite_mem_gib); + println!(); + + let rows = typed_math_microbenchmark::run_extract_comparison_with_iters_and_mem_cap( + args.rewrite_iters, + args.max_rewrite_mem_gib, + ); + + println!("Math Microbenchmark Extract Comparison"); + println!( + "| Extract Method | Requested Iters | Executed Iters | Max Rewrite Mem | Run Ruleset Note | Run Ruleset Peak Mem | Extract Peak Mem | Time | Best Expression | SVG Path |" + ); + println!("| --- | ---: | ---: | ---: | --- | ---: | ---: | ---: | --- | --- |"); + for row in rows { + let rendered = row.rendered.replace('|', "\\|"); + let svg_path = row.svg_path.replace('|', "\\|"); + let note = row.run_ruleset_note.replace('|', "\\|"); + println!( + "| {} | {} | {} | {} GiB | {} | {} | {} | {} | `{}` | `{}` |", + row.method, + row.requested_rewrite_iters, + row.executed_rewrite_iters, + row.max_rewrite_mem_gib, + note, + format_bytes(row.rewrite_peak_memory_bytes), + format_bytes(row.extract_peak_memory_bytes), + format_duration(row.elapsed), + rendered, + svg_path + ); + } + + Ok(()) + } +} + +#[cfg(feature = "rustsat-extract")] +pub use real::*; + +#[cfg(feature = "rustsat-extract")] +fn main() -> Result<(), Box> { + real::main() +} diff --git a/examples/math_microbenchmark_no_calculus_extract_bench.rs b/examples/math_microbenchmark_no_calculus_extract_bench.rs new file mode 100644 index 0000000..8879937 --- /dev/null +++ b/examples/math_microbenchmark_no_calculus_extract_bench.rs @@ -0,0 +1,133 @@ +#[cfg(not(feature = "rustsat-extract"))] +fn main() { + eprintln!("math_microbenchmark_no_calculus_extract_bench requires --features rustsat-extract"); +} + +#[path = "../benches/runners/eggplant_rewrite/math_microbenchmark_no_calculus.rs"] +mod typed_math_microbenchmark; + +#[cfg(feature = "rustsat-extract")] +mod real { + use super::typed_math_microbenchmark; + use eggplant::helpers::bench_cli::{ExtractBenchCliArgs, parse_extract_bench_args}; + use eggplant::helpers::progress::BenchProgress; + use eggplant::helpers::report::{ + ExtractReportRow, print_extract_comparison_report, print_extract_run_configuration, + }; + + pub type CliArgs = ExtractBenchCliArgs; + + pub fn parse_args(args: I) -> CliArgs + where + I: IntoIterator, + T: Into + Clone, + { + parse_extract_bench_args( + "math_microbenchmark_no_calculus_extract_bench", + "Run the no-calculus math microbenchmark with CLI progress bars", + 11, + 20, + args, + ) + } + + pub fn main() -> Result<(), Box> { + let _ = env_logger::try_init(); + let args = parse_args(std::env::args_os()); + + println!("CPU-style DSL costs used for Math (no calculus):"); + println!("| Op | Cost |"); + println!("| --- | ---: |"); + println!("| MAdd | 1 |"); + println!("| MSub | 1 |"); + println!("| MMul | 3 |"); + println!("| MDiv | 10 |"); + println!("| MPow | 25 |"); + println!("| MLn | 18 |"); + println!("| MSqrt | 16 |"); + println!("| MSin | 18 |"); + println!("| MCos | 18 |"); + println!("| MConst | 0 |"); + println!("| MVar | 0 |"); + println!(); + + println!("Target root:"); + println!("`Div(1, Sub(Div(Add(1, Sqrt(five)), 2), Div(Sub(1, Sqrt(five)), 2)))`"); + println!(); + print_extract_run_configuration(&args); + + let progress = BenchProgress::new(args.rewrite_iters as u64, args.extractors.len() as u64); + + let rows = typed_math_microbenchmark::run_extract_comparison_with_options_and_progress( + args.rewrite_iters, + args.max_rewrite_mem_gib, + &args.extractors, + args.max_extract_time_secs, + |event| match event { + typed_math_microbenchmark::ProgressEvent::RewriteIterationComplete { + current, + total, + tuple_count, + peak_memory_bytes, + } => progress.rewrite_iteration_complete( + current, + total, + tuple_count, + peak_memory_bytes, + ), + typed_math_microbenchmark::ProgressEvent::RewriteStoppedByMemoryCap { + current, + total, + peak_memory_bytes, + cap_bytes, + } => progress.rewrite_stopped(current, total, peak_memory_bytes, cap_bytes), + typed_math_microbenchmark::ProgressEvent::ExtractPhaseStart { + method, + current, + total, + } => progress.extract_phase_start(method, current, total), + typed_math_microbenchmark::ProgressEvent::ExtractPhaseComplete { + method, + current, + total, + elapsed_ms, + peak_memory_bytes, + } => progress.extract_phase_complete( + method, + current, + total, + elapsed_ms, + peak_memory_bytes, + ), + }, + ); + + progress.finish(); + + print_extract_comparison_report( + "Math Microbenchmark No-Calculus Extract Comparison", + rows.into_iter().map(|row| ExtractReportRow { + method: row.method.to_string(), + requested_rewrite_iters: row.requested_rewrite_iters, + executed_rewrite_iters: row.executed_rewrite_iters, + max_rewrite_mem_gib: row.max_rewrite_mem_gib, + run_ruleset_note: row.run_ruleset_note, + rewrite_peak_memory_bytes: row.rewrite_peak_memory_bytes, + extract_peak_memory_bytes: row.extract_peak_memory_bytes, + elapsed: row.elapsed, + rendered: row.rendered, + svg_path: row.svg_path, + }), + ); + + Ok(()) + } +} + +#[cfg(feature = "rustsat-extract")] +pub use real::*; + +#[cfg(feature = "rustsat-extract")] +fn main() -> Result<(), Box> { + real::main() +} diff --git a/examples/math_microbenchmark_no_calculus_timeline_export.rs b/examples/math_microbenchmark_no_calculus_timeline_export.rs new file mode 100644 index 0000000..09c00c7 --- /dev/null +++ b/examples/math_microbenchmark_no_calculus_timeline_export.rs @@ -0,0 +1,114 @@ +#[cfg(not(feature = "rustsat-extract"))] +fn main() { + eprintln!( + "math_microbenchmark_no_calculus_timeline_export requires --features rustsat-extract" + ); +} + +#[path = "../benches/runners/eggplant_rewrite/math_microbenchmark_no_calculus.rs"] +mod typed_math_microbenchmark_no_calculus; + +#[cfg(feature = "rustsat-extract")] +mod real { + use super::typed_math_microbenchmark_no_calculus; + use eggplant::helpers::bench_cli::{ + TimelineExportCliArgs, parse_timeline_export_args, timeline_markdown_output_path, + }; + #[cfg(feature = "timeline-plot")] + use eggplant::helpers::bench_cli::{timeline_markdown_asset_path, timeline_plot_output_path}; + use eggplant::helpers::progress::{BenchProgress, TimelineExtractMetric}; + #[cfg(not(feature = "timeline-plot"))] + use eggplant::helpers::report::write_timeline_markdown_report; + #[cfg(feature = "timeline-plot")] + use eggplant::helpers::report::{ + write_timeline_markdown_report_with_plot, write_timeline_plot_png, + }; + + pub type CliArgs = TimelineExportCliArgs; + + pub fn parse_args(args: I) -> CliArgs + where + I: IntoIterator, + T: Into + Clone, + { + parse_timeline_export_args( + "math_microbenchmark_no_calculus_timeline_export", + "Export no-calculus timeline data with CLI progress bars", + 20, + 12, + "target/math_microbenchmark_no_calculus_timeline.json", + args, + ) + } + + pub fn main() -> Result<(), Box> { + let _ = env_logger::try_init(); + let args = parse_args(std::env::args_os()); + + let progress = BenchProgress::new(args.rewrite_iters as u64, args.extractors.len() as u64); + + let mut report = typed_math_microbenchmark_no_calculus::run_extract_timeline_with_options( + args.rewrite_iters, + args.max_rewrite_mem_gib, + &args.extractors, + args.max_extract_time_secs, + ); + report.version_nickname = args.version_nickname.clone(); + + for point in &report.points { + let metrics = point + .extracts + .iter() + .map(|metric| TimelineExtractMetric { + method: &metric.method, + elapsed_ms: metric.elapsed_ms, + peak_memory_bytes: metric.peak_memory_bytes, + }) + .collect::>(); + progress.timeline_iteration( + point.iteration as u64, + point.iteration, + point.tuple_count, + point.rewrite_peak_memory_bytes, + &metrics, + ); + } + + progress.finish(); + + let output_path = std::path::PathBuf::from(&args.json_out); + if let Some(parent) = output_path.parent() { + std::fs::create_dir_all(parent)?; + } + std::fs::write(&output_path, serde_json::to_string_pretty(&report)?)?; + println!("wrote timeline JSON to {}", output_path.display()); + + let report_title = "Math Microbenchmark Timeline"; + let markdown_path = timeline_markdown_output_path(&args); + #[cfg(feature = "timeline-plot")] + { + let plot_path = timeline_plot_output_path(&args); + write_timeline_plot_png(report_title, &report, &plot_path)?; + println!("wrote timeline PNG plot to {}", plot_path.display()); + let plot_link = timeline_markdown_asset_path(&markdown_path, &plot_path); + write_timeline_markdown_report_with_plot( + report_title, + &report, + &markdown_path, + Some(&plot_link), + )?; + } + #[cfg(not(feature = "timeline-plot"))] + write_timeline_markdown_report(report_title, &report, &markdown_path)?; + println!("wrote timeline Markdown to {}", markdown_path.display()); + Ok(()) + } +} + +#[cfg(feature = "rustsat-extract")] +pub use real::*; + +#[cfg(feature = "rustsat-extract")] +fn main() -> Result<(), Box> { + real::main() +} diff --git a/examples/math_microbenchmark_support.rs b/examples/math_microbenchmark_support.rs index 4082e57..bef599e 100644 --- a/examples/math_microbenchmark_support.rs +++ b/examples/math_microbenchmark_support.rs @@ -45,63 +45,63 @@ fn math_vars(math: &ArcSort, names: &[&'static str]) -> Vec<(&'static str, ArcSo names.iter().map(|name| (*name, math.clone())).collect() } -fn ctor1(ctx: &mut RustRuleContext<'_, '_, '_>, name: &str, a: Value) -> Value { +fn ctor1(ctx: &mut RustRuleContext<'_, '_>, name: &str, a: Value) -> Value { ctx.lookup(name, &[a]).unwrap() } -fn ctor2(ctx: &mut RustRuleContext<'_, '_, '_>, name: &str, a: Value, b: Value) -> Value { +fn ctor2(ctx: &mut RustRuleContext<'_, '_>, name: &str, a: Value, b: Value) -> Value { ctx.lookup(name, &[a, b]).unwrap() } -fn m_diff(ctx: &mut RustRuleContext<'_, '_, '_>, x: Value, f: Value) -> Value { +fn m_diff(ctx: &mut RustRuleContext<'_, '_>, x: Value, f: Value) -> Value { ctor2(ctx, "MDiff", x, f) } -fn m_integral(ctx: &mut RustRuleContext<'_, '_, '_>, f: Value, x: Value) -> Value { +fn m_integral(ctx: &mut RustRuleContext<'_, '_>, f: Value, x: Value) -> Value { ctor2(ctx, "MIntegral", f, x) } -fn m_add(ctx: &mut RustRuleContext<'_, '_, '_>, a: Value, b: Value) -> Value { +fn m_add(ctx: &mut RustRuleContext<'_, '_>, a: Value, b: Value) -> Value { ctor2(ctx, "MAdd", a, b) } -fn m_sub(ctx: &mut RustRuleContext<'_, '_, '_>, a: Value, b: Value) -> Value { +fn m_sub(ctx: &mut RustRuleContext<'_, '_>, a: Value, b: Value) -> Value { ctor2(ctx, "MSub", a, b) } -fn m_mul(ctx: &mut RustRuleContext<'_, '_, '_>, a: Value, b: Value) -> Value { +fn m_mul(ctx: &mut RustRuleContext<'_, '_>, a: Value, b: Value) -> Value { ctor2(ctx, "MMul", a, b) } -fn m_div(ctx: &mut RustRuleContext<'_, '_, '_>, a: Value, b: Value) -> Value { +fn m_div(ctx: &mut RustRuleContext<'_, '_>, a: Value, b: Value) -> Value { ctor2(ctx, "MDiv", a, b) } -fn m_pow(ctx: &mut RustRuleContext<'_, '_, '_>, a: Value, b: Value) -> Value { +fn m_pow(ctx: &mut RustRuleContext<'_, '_>, a: Value, b: Value) -> Value { ctor2(ctx, "MPow", a, b) } -fn m_ln(ctx: &mut RustRuleContext<'_, '_, '_>, a: Value) -> Value { +fn m_ln(ctx: &mut RustRuleContext<'_, '_>, a: Value) -> Value { ctor1(ctx, "MLn", a) } -fn m_sqrt(ctx: &mut RustRuleContext<'_, '_, '_>, a: Value) -> Value { +fn m_sqrt(ctx: &mut RustRuleContext<'_, '_>, a: Value) -> Value { ctor1(ctx, "MSqrt", a) } -fn m_sin(ctx: &mut RustRuleContext<'_, '_, '_>, a: Value) -> Value { +fn m_sin(ctx: &mut RustRuleContext<'_, '_>, a: Value) -> Value { ctor1(ctx, "MSin", a) } -fn m_cos(ctx: &mut RustRuleContext<'_, '_, '_>, a: Value) -> Value { +fn m_cos(ctx: &mut RustRuleContext<'_, '_>, a: Value) -> Value { ctor1(ctx, "MCos", a) } -fn m_const(ctx: &mut RustRuleContext<'_, '_, '_>, n: i64) -> Value { +fn m_const(ctx: &mut RustRuleContext<'_, '_>, n: i64) -> Value { ctor1(ctx, "MConst", ctx.base_to_value::(n)) } -fn m_var(ctx: &mut RustRuleContext<'_, '_, '_>, name: &'static str) -> Value { +fn m_var(ctx: &mut RustRuleContext<'_, '_>, name: &'static str) -> Value { ctor1(ctx, "MVar", ctx.base_to_value::(name.to_owned().into())) } @@ -111,7 +111,7 @@ fn add_math_rule( rule_name: &str, vars: &[(&'static str, ArcSort)], facts: Facts, - action: impl Fn(&mut RustRuleContext<'_, '_, '_>, &[Value]) -> Option<()> + action: impl Fn(&mut RustRuleContext<'_, '_>, &[Value]) -> Option<()> + Clone + Send + Sync @@ -606,3 +606,7 @@ pub fn run_and_collect_stats() -> MathMicrobenchmarkStats { .collect(), } } + +fn main() { + eprintln!("math_microbenchmark_support is a support module; run a wrapper example instead"); +} diff --git a/examples/nncase_clamp_extract_bench.rs b/examples/nncase_clamp_extract_bench.rs new file mode 100644 index 0000000..9e91dee --- /dev/null +++ b/examples/nncase_clamp_extract_bench.rs @@ -0,0 +1,114 @@ +#[cfg(not(feature = "rustsat-extract"))] +fn main() { + eprintln!("nncase_clamp_extract_bench requires --features rustsat-extract"); +} + +#[cfg(feature = "rustsat-extract")] +#[path = "../src/benchmarks/mod.rs"] +mod benchmarks; + +#[cfg(feature = "rustsat-extract")] +mod real { + use crate::benchmarks::nncase_clamp_microbenchmark; + use eggplant::helpers::bench_cli::ExtractBenchCliArgs; + use eggplant::helpers::progress::BenchProgress; + use eggplant::helpers::report::{ + BenchmarkWorkloadSpec, ExtractReportRow, print_benchmark_workload_spec, + print_extract_comparison_report, print_extract_run_configuration, + }; + + pub type CliArgs = ExtractBenchCliArgs; + + pub fn workload_spec() -> BenchmarkWorkloadSpec<'static> { + nncase_clamp_microbenchmark::workload_spec() + } + + pub fn parse_args(args: I) -> CliArgs + where + I: IntoIterator, + T: Into + Clone, + { + nncase_clamp_microbenchmark::parse_extract_args(args) + } + + pub fn main() -> Result<(), Box> { + let _ = env_logger::try_init(); + let args = parse_args(std::env::args_os()); + print_benchmark_workload_spec(&workload_spec()); + print_extract_run_configuration(&args); + let progress = BenchProgress::new(args.rewrite_iters as u64, args.extractors.len() as u64); + let rows = nncase_clamp_microbenchmark::run_extract_comparison_with_options_and_progress( + args.rewrite_iters, + args.max_rewrite_mem_gib, + &args.extractors, + args.max_extract_time_secs, + |event| match event { + nncase_clamp_microbenchmark::ProgressEvent::RewriteIterationComplete { + current, + total, + tuple_count, + peak_memory_bytes, + } => { + progress.rewrite_iteration_complete( + current, + total, + tuple_count, + peak_memory_bytes, + ); + } + nncase_clamp_microbenchmark::ProgressEvent::RewriteStoppedByMemoryCap { + current, + total, + peak_memory_bytes, + cap_bytes, + } => { + progress.rewrite_stopped(current, total, peak_memory_bytes, cap_bytes); + } + nncase_clamp_microbenchmark::ProgressEvent::ExtractPhaseStart { + method, + current, + total, + } => { + progress.extract_phase_start(method, current, total); + } + nncase_clamp_microbenchmark::ProgressEvent::ExtractPhaseComplete { + method, + current, + total, + elapsed_ms, + peak_memory_bytes, + } => { + progress.extract_phase_complete( + method, + current, + total, + elapsed_ms, + peak_memory_bytes, + ); + } + }, + ); + progress.finish(); + print_extract_comparison_report( + "Nncase Clamp Extract Comparison", + rows.into_iter().map(|row| ExtractReportRow { + method: row.method.to_string(), + requested_rewrite_iters: row.requested_rewrite_iters, + executed_rewrite_iters: row.executed_rewrite_iters, + max_rewrite_mem_gib: row.max_rewrite_mem_gib, + run_ruleset_note: row.run_ruleset_note, + rewrite_peak_memory_bytes: row.rewrite_peak_memory_bytes, + extract_peak_memory_bytes: row.extract_peak_memory_bytes, + elapsed: row.elapsed, + rendered: row.rendered, + svg_path: row.svg_path, + }), + ); + Ok(()) + } +} + +#[cfg(feature = "rustsat-extract")] +fn main() -> Result<(), Box> { + real::main() +} diff --git a/examples/nncase_clamp_timeline_export.rs b/examples/nncase_clamp_timeline_export.rs new file mode 100644 index 0000000..d7c5d48 --- /dev/null +++ b/examples/nncase_clamp_timeline_export.rs @@ -0,0 +1,108 @@ +#[cfg(not(feature = "rustsat-extract"))] +fn main() { + eprintln!("nncase_clamp_timeline_export requires --features rustsat-extract"); +} + +#[cfg(feature = "rustsat-extract")] +#[path = "../src/benchmarks/mod.rs"] +mod benchmarks; + +#[cfg(feature = "rustsat-extract")] +mod real { + use crate::benchmarks::nncase_clamp_microbenchmark; + use eggplant::helpers::bench_cli::{TimelineExportCliArgs, timeline_markdown_output_path}; + #[cfg(feature = "timeline-plot")] + use eggplant::helpers::bench_cli::{timeline_markdown_asset_path, timeline_plot_output_path}; + use eggplant::helpers::progress::{BenchProgress, TimelineExtractMetric}; + #[cfg(not(feature = "timeline-plot"))] + use eggplant::helpers::report::{ + BenchmarkWorkloadSpec, print_benchmark_workload_spec, write_timeline_markdown_report, + }; + #[cfg(feature = "timeline-plot")] + use eggplant::helpers::report::{ + BenchmarkWorkloadSpec, print_benchmark_workload_spec, + write_timeline_markdown_report_with_plot, write_timeline_plot_png, + }; + + pub type CliArgs = TimelineExportCliArgs; + + pub fn workload_spec() -> BenchmarkWorkloadSpec<'static> { + nncase_clamp_microbenchmark::workload_spec() + } + + pub fn parse_args(args: I) -> CliArgs + where + I: IntoIterator, + T: Into + Clone, + { + nncase_clamp_microbenchmark::parse_timeline_args(args) + } + + pub fn main() -> Result<(), Box> { + let _ = env_logger::try_init(); + let args = parse_args(std::env::args_os()); + print_benchmark_workload_spec(&workload_spec()); + let progress = BenchProgress::new( + (args.rewrite_iters + 1) as u64, + args.extractors.len() as u64, + ); + let mut report = nncase_clamp_microbenchmark::run_extract_timeline_with_options( + args.rewrite_iters + 1, + args.max_rewrite_mem_gib, + &args.extractors, + args.max_extract_time_secs, + ); + report.version_nickname = args.version_nickname.clone(); + report.requested_rewrite_iters = args.rewrite_iters; + for point in &report.points { + let metrics = point + .extracts + .iter() + .map(|metric| TimelineExtractMetric { + method: &metric.method, + elapsed_ms: metric.elapsed_ms, + peak_memory_bytes: metric.peak_memory_bytes, + }) + .collect::>(); + progress.timeline_iteration( + (point.iteration + 1) as u64, + point.iteration, + point.tuple_count, + point.rewrite_peak_memory_bytes, + &metrics, + ); + } + progress.finish(); + let output_path = std::path::PathBuf::from(&args.json_out); + if let Some(parent) = output_path.parent() { + std::fs::create_dir_all(parent)?; + } + std::fs::write(&output_path, serde_json::to_string_pretty(&report)?)?; + println!("wrote timeline JSON to {}", output_path.display()); + + let report_title = "Nncase Clamp Timeline"; + let markdown_path = timeline_markdown_output_path(&args); + #[cfg(feature = "timeline-plot")] + { + let plot_path = timeline_plot_output_path(&args); + write_timeline_plot_png(report_title, &report, &plot_path)?; + println!("wrote timeline PNG plot to {}", plot_path.display()); + let plot_link = timeline_markdown_asset_path(&markdown_path, &plot_path); + write_timeline_markdown_report_with_plot( + report_title, + &report, + &markdown_path, + Some(&plot_link), + )?; + } + #[cfg(not(feature = "timeline-plot"))] + write_timeline_markdown_report(report_title, &report, &markdown_path)?; + println!("wrote timeline Markdown to {}", markdown_path.display()); + Ok(()) + } +} + +#[cfg(feature = "rustsat-extract")] +fn main() -> Result<(), Box> { + real::main() +} diff --git a/examples/nncase_transpose_extract_bench.rs b/examples/nncase_transpose_extract_bench.rs new file mode 100644 index 0000000..ca36cbd --- /dev/null +++ b/examples/nncase_transpose_extract_bench.rs @@ -0,0 +1,113 @@ +#[cfg(not(feature = "rustsat-extract"))] +fn main() { + eprintln!("nncase_transpose_extract_bench requires --features rustsat-extract"); +} + +#[cfg(feature = "rustsat-extract")] +#[path = "../src/benchmarks/mod.rs"] +mod benchmarks; + +#[cfg(feature = "rustsat-extract")] +mod real { + use crate::benchmarks::nncase_transpose_microbenchmark; + use eggplant::helpers::bench_cli::ExtractBenchCliArgs; + use eggplant::helpers::progress::BenchProgress; + use eggplant::helpers::report::{ + BenchmarkWorkloadSpec, ExtractReportRow, print_benchmark_workload_spec, + print_extract_comparison_report, print_extract_run_configuration, + }; + + pub type CliArgs = ExtractBenchCliArgs; + + pub fn workload_spec() -> BenchmarkWorkloadSpec<'static> { + nncase_transpose_microbenchmark::workload_spec() + } + + pub fn parse_args(args: I) -> CliArgs + where + I: IntoIterator, + T: Into + Clone, + { + nncase_transpose_microbenchmark::parse_extract_args(args) + } + + pub fn main() -> Result<(), Box> { + let _ = env_logger::try_init(); + let args = parse_args(std::env::args_os()); + + print_benchmark_workload_spec(&workload_spec()); + print_extract_run_configuration(&args); + + let progress = BenchProgress::new(args.rewrite_iters as u64, args.extractors.len() as u64); + + let rows = + nncase_transpose_microbenchmark::run_extract_comparison_with_options_and_progress( + args.rewrite_iters, + args.max_rewrite_mem_gib, + &args.extractors, + args.max_extract_time_secs, + |event| match event { + nncase_transpose_microbenchmark::ProgressEvent::RewriteIterationComplete { + current, + total, + tuple_count, + peak_memory_bytes, + } => progress.rewrite_iteration_complete( + current, + total, + tuple_count, + peak_memory_bytes, + ), + nncase_transpose_microbenchmark::ProgressEvent::RewriteStoppedByMemoryCap { + current, + total, + peak_memory_bytes, + cap_bytes, + } => progress.rewrite_stopped(current, total, peak_memory_bytes, cap_bytes), + nncase_transpose_microbenchmark::ProgressEvent::ExtractPhaseStart { + method, + current, + total, + } => progress.extract_phase_start(method, current, total), + nncase_transpose_microbenchmark::ProgressEvent::ExtractPhaseComplete { + method, + current, + total, + elapsed_ms, + peak_memory_bytes, + } => progress.extract_phase_complete( + method, + current, + total, + elapsed_ms, + peak_memory_bytes, + ), + }, + ); + + progress.finish(); + + print_extract_comparison_report( + "Nncase Transpose Extract Comparison", + rows.into_iter().map(|row| ExtractReportRow { + method: row.method.to_string(), + requested_rewrite_iters: row.requested_rewrite_iters, + executed_rewrite_iters: row.executed_rewrite_iters, + max_rewrite_mem_gib: row.max_rewrite_mem_gib, + run_ruleset_note: row.run_ruleset_note, + rewrite_peak_memory_bytes: row.rewrite_peak_memory_bytes, + extract_peak_memory_bytes: row.extract_peak_memory_bytes, + elapsed: row.elapsed, + rendered: row.rendered, + svg_path: row.svg_path, + }), + ); + + Ok(()) + } +} + +#[cfg(feature = "rustsat-extract")] +fn main() -> Result<(), Box> { + real::main() +} diff --git a/examples/nncase_transpose_timeline_export.rs b/examples/nncase_transpose_timeline_export.rs new file mode 100644 index 0000000..ce2e379 --- /dev/null +++ b/examples/nncase_transpose_timeline_export.rs @@ -0,0 +1,113 @@ +#[cfg(not(feature = "rustsat-extract"))] +fn main() { + eprintln!("nncase_transpose_timeline_export requires --features rustsat-extract"); +} + +#[cfg(feature = "rustsat-extract")] +#[path = "../src/benchmarks/mod.rs"] +mod benchmarks; + +#[cfg(feature = "rustsat-extract")] +mod real { + use crate::benchmarks::nncase_transpose_microbenchmark; + use eggplant::helpers::bench_cli::{TimelineExportCliArgs, timeline_markdown_output_path}; + #[cfg(feature = "timeline-plot")] + use eggplant::helpers::bench_cli::{timeline_markdown_asset_path, timeline_plot_output_path}; + use eggplant::helpers::progress::{BenchProgress, TimelineExtractMetric}; + #[cfg(not(feature = "timeline-plot"))] + use eggplant::helpers::report::{ + BenchmarkWorkloadSpec, print_benchmark_workload_spec, write_timeline_markdown_report, + }; + #[cfg(feature = "timeline-plot")] + use eggplant::helpers::report::{ + BenchmarkWorkloadSpec, print_benchmark_workload_spec, + write_timeline_markdown_report_with_plot, write_timeline_plot_png, + }; + + pub type CliArgs = TimelineExportCliArgs; + + pub fn workload_spec() -> BenchmarkWorkloadSpec<'static> { + nncase_transpose_microbenchmark::workload_spec() + } + + pub fn parse_args(args: I) -> CliArgs + where + I: IntoIterator, + T: Into + Clone, + { + nncase_transpose_microbenchmark::parse_timeline_args(args) + } + + pub fn main() -> Result<(), Box> { + let _ = env_logger::try_init(); + let args = parse_args(std::env::args_os()); + print_benchmark_workload_spec(&workload_spec()); + + let progress = BenchProgress::new( + (args.rewrite_iters + 1) as u64, + args.extractors.len() as u64, + ); + + let mut report = nncase_transpose_microbenchmark::run_extract_timeline_with_options( + args.rewrite_iters + 1, + args.max_rewrite_mem_gib, + &args.extractors, + args.max_extract_time_secs, + ); + report.version_nickname = args.version_nickname.clone(); + report.requested_rewrite_iters = args.rewrite_iters; + + for point in &report.points { + let metrics = point + .extracts + .iter() + .map(|metric| TimelineExtractMetric { + method: &metric.method, + elapsed_ms: metric.elapsed_ms, + peak_memory_bytes: metric.peak_memory_bytes, + }) + .collect::>(); + progress.timeline_iteration( + (point.iteration + 1) as u64, + point.iteration, + point.tuple_count, + point.rewrite_peak_memory_bytes, + &metrics, + ); + } + + progress.finish(); + + let output_path = std::path::PathBuf::from(&args.json_out); + if let Some(parent) = output_path.parent() { + std::fs::create_dir_all(parent)?; + } + std::fs::write(&output_path, serde_json::to_string_pretty(&report)?)?; + println!("wrote timeline JSON to {}", output_path.display()); + + let report_title = "Nncase Transpose Timeline"; + let markdown_path = timeline_markdown_output_path(&args); + #[cfg(feature = "timeline-plot")] + { + let plot_path = timeline_plot_output_path(&args); + write_timeline_plot_png(report_title, &report, &plot_path)?; + println!("wrote timeline PNG plot to {}", plot_path.display()); + let plot_link = timeline_markdown_asset_path(&markdown_path, &plot_path); + write_timeline_markdown_report_with_plot( + report_title, + &report, + &markdown_path, + Some(&plot_link), + )?; + } + #[cfg(not(feature = "timeline-plot"))] + write_timeline_markdown_report(report_title, &report, &markdown_path)?; + println!("wrote timeline Markdown to {}", markdown_path.display()); + Ok(()) + } +} + +#[cfg(feature = "rustsat-extract")] +fn main() -> Result<(), Box> { + real::main() +} diff --git a/examples/nncase_vectorize_extract_bench.rs b/examples/nncase_vectorize_extract_bench.rs new file mode 100644 index 0000000..fdc0c46 --- /dev/null +++ b/examples/nncase_vectorize_extract_bench.rs @@ -0,0 +1,115 @@ +#[cfg(not(feature = "rustsat-extract"))] +fn main() { + eprintln!("nncase_vectorize_extract_bench requires --features rustsat-extract"); +} + +#[cfg(feature = "rustsat-extract")] +#[path = "../src/benchmarks/mod.rs"] +mod benchmarks; + +#[cfg(feature = "rustsat-extract")] +mod real { + use crate::benchmarks::nncase_vectorize_microbenchmark; + use eggplant::helpers::bench_cli::ExtractBenchCliArgs; + use eggplant::helpers::progress::BenchProgress; + use eggplant::helpers::report::{ + BenchmarkWorkloadSpec, ExtractReportRow, print_benchmark_workload_spec, + print_extract_comparison_report, print_extract_run_configuration, + }; + + pub type CliArgs = ExtractBenchCliArgs; + + pub fn workload_spec() -> BenchmarkWorkloadSpec<'static> { + nncase_vectorize_microbenchmark::workload_spec() + } + + pub fn parse_args(args: I) -> CliArgs + where + I: IntoIterator, + T: Into + Clone, + { + nncase_vectorize_microbenchmark::parse_extract_args(args) + } + + pub fn main() -> Result<(), Box> { + let _ = env_logger::try_init(); + let args = parse_args(std::env::args_os()); + print_benchmark_workload_spec(&workload_spec()); + print_extract_run_configuration(&args); + let progress = BenchProgress::new(args.rewrite_iters as u64, args.extractors.len() as u64); + let rows = + nncase_vectorize_microbenchmark::run_extract_comparison_with_options_and_progress( + args.rewrite_iters, + args.max_rewrite_mem_gib, + &args.extractors, + args.max_extract_time_secs, + |event| match event { + nncase_vectorize_microbenchmark::ProgressEvent::RewriteIterationComplete { + current, + total, + tuple_count, + peak_memory_bytes, + } => { + progress.rewrite_iteration_complete( + current, + total, + tuple_count, + peak_memory_bytes, + ); + } + nncase_vectorize_microbenchmark::ProgressEvent::RewriteStoppedByMemoryCap { + current, + total, + peak_memory_bytes, + cap_bytes, + } => { + progress.rewrite_stopped(current, total, peak_memory_bytes, cap_bytes); + } + nncase_vectorize_microbenchmark::ProgressEvent::ExtractPhaseStart { + method, + current, + total, + } => { + progress.extract_phase_start(method, current, total); + } + nncase_vectorize_microbenchmark::ProgressEvent::ExtractPhaseComplete { + method, + current, + total, + elapsed_ms, + peak_memory_bytes, + } => { + progress.extract_phase_complete( + method, + current, + total, + elapsed_ms, + peak_memory_bytes, + ); + } + }, + ); + progress.finish(); + print_extract_comparison_report( + "Nncase Vectorize Extract Comparison", + rows.into_iter().map(|row| ExtractReportRow { + method: row.method.to_string(), + requested_rewrite_iters: row.requested_rewrite_iters, + executed_rewrite_iters: row.executed_rewrite_iters, + max_rewrite_mem_gib: row.max_rewrite_mem_gib, + run_ruleset_note: row.run_ruleset_note, + rewrite_peak_memory_bytes: row.rewrite_peak_memory_bytes, + extract_peak_memory_bytes: row.extract_peak_memory_bytes, + elapsed: row.elapsed, + rendered: row.rendered, + svg_path: row.svg_path, + }), + ); + Ok(()) + } +} + +#[cfg(feature = "rustsat-extract")] +fn main() -> Result<(), Box> { + real::main() +} diff --git a/examples/nncase_vectorize_timeline_export.rs b/examples/nncase_vectorize_timeline_export.rs new file mode 100644 index 0000000..a708865 --- /dev/null +++ b/examples/nncase_vectorize_timeline_export.rs @@ -0,0 +1,108 @@ +#[cfg(not(feature = "rustsat-extract"))] +fn main() { + eprintln!("nncase_vectorize_timeline_export requires --features rustsat-extract"); +} + +#[cfg(feature = "rustsat-extract")] +#[path = "../src/benchmarks/mod.rs"] +mod benchmarks; + +#[cfg(feature = "rustsat-extract")] +mod real { + use crate::benchmarks::nncase_vectorize_microbenchmark; + use eggplant::helpers::bench_cli::{TimelineExportCliArgs, timeline_markdown_output_path}; + #[cfg(feature = "timeline-plot")] + use eggplant::helpers::bench_cli::{timeline_markdown_asset_path, timeline_plot_output_path}; + use eggplant::helpers::progress::{BenchProgress, TimelineExtractMetric}; + #[cfg(not(feature = "timeline-plot"))] + use eggplant::helpers::report::{ + BenchmarkWorkloadSpec, print_benchmark_workload_spec, write_timeline_markdown_report, + }; + #[cfg(feature = "timeline-plot")] + use eggplant::helpers::report::{ + BenchmarkWorkloadSpec, print_benchmark_workload_spec, + write_timeline_markdown_report_with_plot, write_timeline_plot_png, + }; + + pub type CliArgs = TimelineExportCliArgs; + + pub fn workload_spec() -> BenchmarkWorkloadSpec<'static> { + nncase_vectorize_microbenchmark::workload_spec() + } + + pub fn parse_args(args: I) -> CliArgs + where + I: IntoIterator, + T: Into + Clone, + { + nncase_vectorize_microbenchmark::parse_timeline_args(args) + } + + pub fn main() -> Result<(), Box> { + let _ = env_logger::try_init(); + let args = parse_args(std::env::args_os()); + print_benchmark_workload_spec(&workload_spec()); + let progress = BenchProgress::new( + (args.rewrite_iters + 1) as u64, + args.extractors.len() as u64, + ); + let mut report = nncase_vectorize_microbenchmark::run_extract_timeline_with_options( + args.rewrite_iters + 1, + args.max_rewrite_mem_gib, + &args.extractors, + args.max_extract_time_secs, + ); + report.version_nickname = args.version_nickname.clone(); + report.requested_rewrite_iters = args.rewrite_iters; + for point in &report.points { + let metrics = point + .extracts + .iter() + .map(|metric| TimelineExtractMetric { + method: &metric.method, + elapsed_ms: metric.elapsed_ms, + peak_memory_bytes: metric.peak_memory_bytes, + }) + .collect::>(); + progress.timeline_iteration( + (point.iteration + 1) as u64, + point.iteration, + point.tuple_count, + point.rewrite_peak_memory_bytes, + &metrics, + ); + } + progress.finish(); + let output_path = std::path::PathBuf::from(&args.json_out); + if let Some(parent) = output_path.parent() { + std::fs::create_dir_all(parent)?; + } + std::fs::write(&output_path, serde_json::to_string_pretty(&report)?)?; + println!("wrote timeline JSON to {}", output_path.display()); + + let report_title = "Nncase Vectorize Timeline"; + let markdown_path = timeline_markdown_output_path(&args); + #[cfg(feature = "timeline-plot")] + { + let plot_path = timeline_plot_output_path(&args); + write_timeline_plot_png(report_title, &report, &plot_path)?; + println!("wrote timeline PNG plot to {}", plot_path.display()); + let plot_link = timeline_markdown_asset_path(&markdown_path, &plot_path); + write_timeline_markdown_report_with_plot( + report_title, + &report, + &markdown_path, + Some(&plot_link), + )?; + } + #[cfg(not(feature = "timeline-plot"))] + write_timeline_markdown_report(report_title, &report, &markdown_path)?; + println!("wrote timeline Markdown to {}", markdown_path.display()); + Ok(()) + } +} + +#[cfg(feature = "rustsat-extract")] +fn main() -> Result<(), Box> { + real::main() +} diff --git a/src/benchmarks/mod.rs b/src/benchmarks/mod.rs new file mode 100644 index 0000000..8625bce --- /dev/null +++ b/src/benchmarks/mod.rs @@ -0,0 +1,3 @@ +pub mod nncase_clamp_microbenchmark; +pub mod nncase_transpose_microbenchmark; +pub mod nncase_vectorize_microbenchmark; diff --git a/src/benchmarks/nncase_clamp_microbenchmark.rs b/src/benchmarks/nncase_clamp_microbenchmark.rs new file mode 100644 index 0000000..92983c6 --- /dev/null +++ b/src/benchmarks/nncase_clamp_microbenchmark.rs @@ -0,0 +1,827 @@ +use egglog_reports::RunReport; +use eggplant::prelude::*; +use eggplant::tx_rx_vt_pr; +use eggplant::wrap::NonPatRecSgl; +use serde::{Deserialize, Serialize}; +use std::collections::BTreeMap; +use std::path::PathBuf; +use std::time::{Duration, Instant}; + +#[cfg(feature = "rustsat-extract")] +use eggplant::egglog::extract::TreeAdditiveCostModel; +#[cfg(feature = "rustsat-extract")] +use eggplant::wrap::EgglogTy; +#[cfg(feature = "rustsat-extract")] +use std::fs; + +#[eggplant::dsl] +enum ClampExpr { + #[display("{name}")] + #[typst("{name}")] + #[precedence(100)] + #[cost(0)] + Input { name: String }, + #[typst("w_({name})")] + #[precedence(100)] + #[cost(0)] + Weight { name: String }, + #[typst("({input} * {weight})")] + #[precedence(60)] + #[cost(12)] + Conv2D { input: ClampExpr, weight: ClampExpr }, + #[typst("|{inner}|")] + #[precedence(90)] + #[cost(4)] + Relu { inner: ClampExpr }, + #[typst("|{inner}|_6")] + #[precedence(90)] + #[cost(4)] + Relu6 { inner: ClampExpr }, + #[typst("[{inner}]")] + #[precedence(90)] + #[cost(2)] + ClampZeroInf { inner: ClampExpr }, + #[typst("[{inner}]_6")] + #[precedence(90)] + #[cost(2)] + ClampZeroSix { inner: ClampExpr }, + #[typst("(({input} * {weight}))_f")] + #[precedence(60)] + #[cost(1)] + FusedConv2D { input: ClampExpr, weight: ClampExpr }, +} + +tx_rx_vt_pr!(NncaseClampTx, NncaseClampPatRec); + +pub struct MathExtractComparisonRow { + pub method: &'static str, + pub requested_rewrite_iters: usize, + pub executed_rewrite_iters: usize, + pub max_rewrite_mem_gib: u64, + pub run_ruleset_note: String, + pub rewrite_peak_memory_bytes: u64, + pub extract_peak_memory_bytes: Option, + pub cost: Option, + pub elapsed: Option, + pub rendered: String, + pub svg_path: String, + pub timed_out: bool, +} + +#[derive(Debug, Clone)] +pub enum ProgressEvent { + RewriteIterationComplete { + current: usize, + total: usize, + tuple_count: usize, + peak_memory_bytes: u64, + }, + RewriteStoppedByMemoryCap { + current: usize, + total: usize, + peak_memory_bytes: u64, + cap_bytes: u64, + }, + ExtractPhaseStart { + method: &'static str, + current: usize, + total: usize, + }, + ExtractPhaseComplete { + method: &'static str, + current: usize, + total: usize, + elapsed_ms: f64, + peak_memory_bytes: u64, + }, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ExtractTimelineMetric { + pub method: String, + pub cost: Option, + pub elapsed_ms: Option, + pub peak_memory_bytes: Option, + pub svg_path: String, + pub timed_out: bool, +} + +#[derive(Debug, Clone, Serialize)] +pub struct RewriteTimelinePoint { + pub iteration: usize, + pub tuple_count: usize, + pub rewrite_elapsed_ms: f64, + pub rewrite_peak_memory_bytes: u64, + pub rule_matches: BTreeMap, + pub extracts: Vec, +} + +#[derive(Debug, Clone, Serialize)] +pub struct ExtractTimelineReport { + pub version_nickname: Option, + pub benchmark_family: &'static str, + pub benchmark_case: &'static str, + pub baseline: &'static str, + pub comparison_target: &'static str, + pub positioning: &'static str, + pub selected_extractors: Vec, + pub max_extract_time_secs: Option, + pub requested_rewrite_iters: usize, + pub executed_rewrite_iters: usize, + pub max_rewrite_mem_gib: u64, + pub stopped_early_due_to_memory_cap: bool, + pub points: Vec, +} + +pub struct NncaseClampStats { + pub max_rewrite_mem_gib: u64, + pub rewrite_peak_memory_bytes: u64, + pub requested_rewrite_iters: usize, + pub executed_rewrite_iters: usize, + pub rewrite_stopped_early_due_to_memory_cap: bool, +} + +#[cfg(feature = "rustsat-extract")] +const ALL_EXTRACT_METHODS: &[&str] = &["default", "eboost", "layered", "rustsat"]; + +const OP_COSTS: &[(&str, u64)] = &[ + ("Input", 0), + ("Weight", 0), + ("Conv2D", 12), + ("Relu", 4), + ("Relu6", 4), + ("ClampZeroInf", 2), + ("ClampZeroSix", 2), + ("FusedConv2D", 1), +]; + +const REWRITE_RULES: &[&str] = &[ + "relu_to_clamp", + "relu6_to_clamp", + "fold_nested_clamp", + "fuse_clamp_conv2d", +]; + +const RULE_WITNESSES: &[(&str, &str)] = &[ + ("relu_to_clamp", "Relu(Conv2D(input, w0))"), + ("relu6_to_clamp", "Relu6(Conv2D(input, w0))"), + ( + "fold_nested_clamp", + "ClampZeroInf(ClampZeroInf(Conv2D(input, w0)))", + ), + ("fuse_clamp_conv2d", "ClampZeroInf(Conv2D(input, w0))"), +]; + +pub fn workload_spec() -> eggplant::helpers::report::BenchmarkWorkloadSpec<'static> { + eggplant::helpers::report::BenchmarkWorkloadSpec { + positioning: eggplant::helpers::report::nncase_benchmark_positioning("clamp"), + op_costs: OP_COSTS, + target_root: "Relu(Conv2D(input, w0))", + rewrite_rules: REWRITE_RULES, + rule_witnesses: RULE_WITNESSES, + } +} + +pub type ExtractCliArgs = eggplant::helpers::bench_cli::ExtractBenchCliArgs; +pub type TimelineCliArgs = eggplant::helpers::bench_cli::TimelineExportCliArgs; + +pub fn parse_extract_args(args: I) -> ExtractCliArgs +where + I: IntoIterator, + T: Into + Clone, +{ + eggplant::helpers::bench_cli::parse_extract_bench_args( + "nncase_clamp_extract_bench", + "Run the nncase clamp microbenchmark with CLI progress bars", + 8, + 20, + args, + ) +} + +pub fn parse_timeline_args(args: I) -> TimelineCliArgs +where + I: IntoIterator, + T: Into + Clone, +{ + eggplant::helpers::bench_cli::parse_timeline_export_args( + "nncase_clamp_timeline_export", + "Export nncase clamp timeline data with CLI progress bars", + 8, + 12, + "target/nncase_clamp_timeline.json", + args, + ) +} + +fn register_rewrite_rules(rs: RuleSetId) { + NncaseClampTx::add_rule( + "relu_to_clamp", + rs, + || { + let inner = ClampExpr::query_leaf(); + let relu = Relu::query(&inner); + #[eggplant::pat_vars] + struct Pat { + inner: ClampExpr, + relu: Relu, + } + Pat::new(inner, relu) + }, + |ctx, pat| { + let rhs = ctx.insert_clamp_zero_inf(pat.inner); + ctx.union(pat.relu, rhs); + }, + ); + NncaseClampTx::add_rule( + "relu6_to_clamp", + rs, + || { + let inner = ClampExpr::query_leaf(); + let relu = Relu6::query(&inner); + #[eggplant::pat_vars] + struct Pat { + inner: ClampExpr, + relu: Relu6, + } + Pat::new(inner, relu) + }, + |ctx, pat| { + let rhs = ctx.insert_clamp_zero_six(pat.inner); + ctx.union(pat.relu, rhs); + }, + ); + NncaseClampTx::add_rule( + "fold_nested_clamp", + rs, + || { + let inner = ClampExpr::query_leaf(); + let inner_clamp = ClampZeroInf::query(&inner); + let outer_clamp = ClampZeroInf::query(&inner_clamp); + #[eggplant::pat_vars] + struct Pat { + inner_clamp: ClampZeroInf, + outer_clamp: ClampZeroInf, + } + Pat::new(inner_clamp, outer_clamp) + }, + |ctx, pat| { + ctx.union(pat.outer_clamp, pat.inner_clamp); + }, + ); + NncaseClampTx::add_rule( + "fuse_clamp_conv2d", + rs, + || { + let input = ClampExpr::query_leaf(); + let weight = ClampExpr::query_leaf(); + let conv = Conv2D::query(&input, &weight); + let clamp = ClampZeroInf::query(&conv); + #[eggplant::pat_vars] + struct Pat { + input: ClampExpr, + weight: ClampExpr, + clamp: ClampZeroInf, + } + Pat::new(input, weight, clamp) + }, + |ctx, pat| { + let rhs = ctx.insert_fused_conv2_d(pat.input, pat.weight); + ctx.union(pat.clamp, rhs); + }, + ); +} + +fn seed_domain(seed_name: &'static str) { + let seed = NncaseClampTx::new_ruleset(seed_name); + NncaseClampTx::add_rule( + seed_name, + seed, + || { + #[eggplant::pat_vars_catch] + struct Unit {} + }, + |ctx, _pat| { + let input = ctx.insert_input("input".to_owned()); + let weight = ctx.insert_weight("w0".to_owned()); + let conv = ctx.insert_conv2_d(input, weight); + ctx.insert_relu(conv); + ctx.insert_relu6(conv); + let clamp = ctx.insert_clamp_zero_inf(conv); + ctx.insert_clamp_zero_inf(clamp); + }, + ); + NncaseClampTx::run_ruleset(seed, RunConfig::Once); +} + +pub fn run_and_collect_stats_iters_with_mem_cap_and_progress( + rewrite_iters: usize, + max_rewrite_mem_gib: u64, + mut on_progress: F, +) -> NncaseClampStats +where + F: FnMut(ProgressEvent), +{ + let max_rewrite_mem_bytes = gib_to_bytes(max_rewrite_mem_gib); + NncaseClampTx::reset_for_bench(); + seed_domain("nncase_clamp_seed"); + let rs = NncaseClampTx::new_ruleset("nncase_clamp_rules"); + register_rewrite_rules(rs); + let rewrite_peak_before = current_peak_memory_bytes(); + let mut executed_rewrite_iters = 0usize; + let mut rewrite_stopped_early_due_to_memory_cap = false; + for _ in 0..rewrite_iters { + NncaseClampTx::run_ruleset(rs, RunConfig::Once); + let current_peak = current_peak_memory_bytes(); + let tuple_count = { + let egraph = ::egraph(); + let egraph = egraph.lock().unwrap(); + egraph.num_tuples() + }; + executed_rewrite_iters += 1; + on_progress(ProgressEvent::RewriteIterationComplete { + current: executed_rewrite_iters, + total: rewrite_iters, + tuple_count, + peak_memory_bytes: current_peak, + }); + if current_peak > max_rewrite_mem_bytes { + rewrite_stopped_early_due_to_memory_cap = true; + on_progress(ProgressEvent::RewriteStoppedByMemoryCap { + current: executed_rewrite_iters, + total: rewrite_iters, + peak_memory_bytes: current_peak, + cap_bytes: max_rewrite_mem_bytes, + }); + break; + } + } + let rewrite_peak_after = current_peak_memory_bytes(); + NncaseClampStats { + max_rewrite_mem_gib, + rewrite_peak_memory_bytes: rewrite_peak_after.saturating_sub(rewrite_peak_before), + requested_rewrite_iters: rewrite_iters, + executed_rewrite_iters, + rewrite_stopped_early_due_to_memory_cap, + } +} + +#[cfg(feature = "rustsat-extract")] +fn build_extract_target() -> impl EgglogNode + EgglogTy + 'static { + let input = Input::::new("input".to_owned()); + input.commit(); + let weight = Weight::::new("w0".to_owned()); + weight.commit(); + let conv = Conv2D::::new(&input, &weight); + conv.commit(); + let root = Relu::::new(&conv); + root.commit(); + root +} + +#[cfg(feature = "rustsat-extract")] +fn extract_backend_for_method(method: &'static str) -> ExtractBackend { + match method { + "default" => ExtractBackend::cost_model(TreeAdditiveCostModel::default()), + "eboost" => { + ExtractBackend::::eboost_heuristic(EBoostExtractConfig::default()) + } + "layered" => { + ExtractBackend::::eboost_layered(EBoostLayeredConfig::default()) + } + "rustsat" => { + ExtractBackend::::rustsat(RustsatExtractConfig::default()) + } + other => panic!("unsupported extract method `{other}`"), + } +} + +#[cfg(feature = "rustsat-extract")] +fn parse_extract_methods(methods: &[String]) -> Vec<&'static str> { + if methods.is_empty() { + return ALL_EXTRACT_METHODS.to_vec(); + } + methods + .iter() + .map(|method| match method.as_str() { + "default" => "default", + "eboost" => "eboost", + "layered" => "layered", + "rustsat" => "rustsat", + other => panic!("unsupported extract method `{other}`"), + }) + .collect() +} + +#[cfg(feature = "rustsat-extract")] +fn render_svg_for_method(target: &N, method: &'static str, svg_path: &PathBuf) -> u64 +where + N: EgglogNode + EgglogTy + 'static, +{ + NncaseClampTx::extract_node_to_svg_with_backend( + target, + extract_backend_for_method(method), + svg_path, + ) + .expect("svg rendering should succeed") +} + +#[cfg(feature = "rustsat-extract")] +fn benchmark_extract_backend( + target: &N, + method: &'static str, + rewrite_peak_memory_bytes: u64, +) -> MathExtractComparisonRow +where + N: EgglogNode + EgglogTy + 'static, +{ + let extract_peak_before = current_peak_memory_bytes(); + let started = Instant::now(); + let (rendered, cost) = NncaseClampTx::extract_node_to_string_with_backend( + target, + extract_backend_for_method(method), + ) + .expect("clamp extraction should succeed"); + let svg_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("target") + .join("nncase_clamp_extract_svgs"); + fs::create_dir_all(&svg_dir).expect("svg output directory should be creatable"); + let svg_path = svg_dir.join(format!("{method}.svg")); + let _ = render_svg_for_method(target, method, &svg_path); + let extract_peak_after = current_peak_memory_bytes(); + MathExtractComparisonRow { + method, + requested_rewrite_iters: 0, + executed_rewrite_iters: 0, + max_rewrite_mem_gib: 0, + run_ruleset_note: String::new(), + rewrite_peak_memory_bytes, + extract_peak_memory_bytes: Some(extract_peak_after.saturating_sub(extract_peak_before)), + cost: Some(cost), + elapsed: Some(started.elapsed()), + rendered, + svg_path: svg_path.display().to_string(), + timed_out: false, + } +} + +#[cfg(feature = "rustsat-extract")] +#[derive(Debug, Clone, Serialize, Deserialize)] +struct TimedExtractComparisonPayload { + rendered: String, + cost: u64, + elapsed_ms: f64, + peak_memory_bytes: u64, + svg_path: String, +} + +#[cfg(feature = "rustsat-extract")] +fn timeout_row(method: &'static str, rewrite_peak_memory_bytes: u64) -> MathExtractComparisonRow { + MathExtractComparisonRow { + method, + requested_rewrite_iters: 0, + executed_rewrite_iters: 0, + max_rewrite_mem_gib: 0, + run_ruleset_note: String::new(), + rewrite_peak_memory_bytes, + extract_peak_memory_bytes: None, + cost: None, + elapsed: None, + rendered: "NaN".to_string(), + svg_path: "n/a".to_string(), + timed_out: true, + } +} + +fn benchmark_extract_backend_with_timeout( + target: &N, + method: &'static str, + rewrite_peak_memory_bytes: u64, + max_extract_time_secs: Option, +) -> MathExtractComparisonRow +where + N: EgglogNode + EgglogTy + 'static, +{ + let payload = run_with_timeout_payload( + max_extract_time_secs, + || { + let row = benchmark_extract_backend(target, method, rewrite_peak_memory_bytes); + TimedExtractComparisonPayload { + rendered: row.rendered, + cost: row.cost.unwrap_or(0), + elapsed_ms: row.elapsed.map(duration_to_ms).unwrap_or(0.0), + peak_memory_bytes: row.extract_peak_memory_bytes.unwrap_or(0), + svg_path: row.svg_path, + } + }, + || TimedExtractComparisonPayload { + rendered: "NaN".to_string(), + cost: 0, + elapsed_ms: f64::NAN, + peak_memory_bytes: 0, + svg_path: "n/a".to_string(), + }, + ); + if payload.elapsed_ms.is_nan() { + timeout_row(method, rewrite_peak_memory_bytes) + } else { + MathExtractComparisonRow { + method, + requested_rewrite_iters: 0, + executed_rewrite_iters: 0, + max_rewrite_mem_gib: 0, + run_ruleset_note: String::new(), + rewrite_peak_memory_bytes, + extract_peak_memory_bytes: Some(payload.peak_memory_bytes), + cost: Some(payload.cost), + elapsed: Some(duration_from_ms(payload.elapsed_ms)), + rendered: payload.rendered, + svg_path: payload.svg_path, + timed_out: false, + } + } +} + +#[cfg(feature = "rustsat-extract")] +fn measure_extract_metric( + target: &N, + iteration: usize, + method: &'static str, +) -> ExtractTimelineMetric +where + N: EgglogNode + EgglogTy + 'static, +{ + let extract_peak_before = current_peak_memory_bytes(); + let started = Instant::now(); + let (_rendered, cost) = NncaseClampTx::extract_node_to_string_with_backend( + target, + extract_backend_for_method(method), + ) + .expect("timeline extract should succeed"); + let elapsed_ms = elapsed_ms(started); + let svg_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("target") + .join("nncase_clamp_timeline_svgs") + .join(format!("iter_{iteration:03}")); + fs::create_dir_all(&svg_dir).expect("timeline svg output directory should be creatable"); + let svg_path = svg_dir.join(format!("{method}.svg")); + let _ = render_svg_for_method(target, method, &svg_path); + let extract_peak_after = current_peak_memory_bytes(); + ExtractTimelineMetric { + method: method.to_string(), + cost: Some(cost), + elapsed_ms: Some(elapsed_ms), + peak_memory_bytes: Some(extract_peak_after.saturating_sub(extract_peak_before)), + svg_path: svg_path.display().to_string(), + timed_out: false, + } +} + +fn measure_extract_metric_with_timeout( + target: &N, + iteration: usize, + method: &'static str, + max_extract_time_secs: Option, +) -> ExtractTimelineMetric +where + N: EgglogNode + EgglogTy + 'static, +{ + run_with_timeout_payload( + max_extract_time_secs, + || measure_extract_metric(target, iteration, method), + || ExtractTimelineMetric { + method: method.to_string(), + cost: None, + elapsed_ms: None, + peak_memory_bytes: None, + svg_path: "n/a".to_string(), + timed_out: true, + }, + ) +} + +#[cfg(feature = "rustsat-extract")] +pub fn run_extract_comparison_with_iters_and_mem_cap( + rewrite_iters: usize, + max_rewrite_mem_gib: u64, +) -> Vec { + run_extract_comparison_with_options_and_progress( + rewrite_iters, + max_rewrite_mem_gib, + &[], + None, + |_| {}, + ) +} + +#[cfg(feature = "rustsat-extract")] +pub fn run_extract_comparison_with_options_and_progress( + rewrite_iters: usize, + max_rewrite_mem_gib: u64, + selected_extractors: &[String], + max_extract_time_secs: Option, + mut on_progress: F, +) -> Vec +where + F: FnMut(ProgressEvent), +{ + let extract_methods = parse_extract_methods(selected_extractors); + let stats = run_and_collect_stats_iters_with_mem_cap_and_progress( + rewrite_iters, + max_rewrite_mem_gib, + |event| on_progress(event), + ); + let target = build_extract_target(); + let mut rows = Vec::new(); + for (index, method) in extract_methods.iter().enumerate() { + on_progress(ProgressEvent::ExtractPhaseStart { + method, + current: index + 1, + total: extract_methods.len(), + }); + let mut row = benchmark_extract_backend_with_timeout( + &target, + method, + stats.rewrite_peak_memory_bytes, + max_extract_time_secs, + ); + row.requested_rewrite_iters = stats.requested_rewrite_iters; + row.executed_rewrite_iters = stats.executed_rewrite_iters; + row.max_rewrite_mem_gib = stats.max_rewrite_mem_gib; + row.run_ruleset_note = if stats.rewrite_stopped_early_due_to_memory_cap { + format!( + "stopped early at {} / {} iterations because peak memory exceeded {} GiB", + stats.executed_rewrite_iters, + stats.requested_rewrite_iters, + stats.max_rewrite_mem_gib + ) + } else { + "completed requested iterations".to_string() + }; + on_progress(ProgressEvent::ExtractPhaseComplete { + method, + current: index + 1, + total: extract_methods.len(), + elapsed_ms: row.elapsed.map(duration_to_ms).unwrap_or(f64::NAN), + peak_memory_bytes: row.extract_peak_memory_bytes.unwrap_or(0), + }); + rows.push(row); + } + rows +} + +#[cfg(feature = "rustsat-extract")] +pub fn run_extract_timeline_with_iters_and_mem_cap( + rewrite_iters: usize, + max_rewrite_mem_gib: u64, +) -> ExtractTimelineReport { + run_extract_timeline_with_options(rewrite_iters, max_rewrite_mem_gib, &[], None) +} + +#[cfg(feature = "rustsat-extract")] +pub fn run_extract_timeline_with_options( + rewrite_iters: usize, + max_rewrite_mem_gib: u64, + selected_extractors: &[String], + max_extract_time_secs: Option, +) -> ExtractTimelineReport { + let max_rewrite_mem_bytes = gib_to_bytes(max_rewrite_mem_gib); + let extract_methods = parse_extract_methods(selected_extractors); + NncaseClampTx::reset_for_bench(); + seed_domain("nncase_clamp_timeline_seed"); + let rs = NncaseClampTx::new_ruleset("nncase_clamp_timeline_rules"); + register_rewrite_rules(rs); + let target = build_extract_target(); + let rewrite_peak_before = current_peak_memory_bytes(); + let mut points = Vec::new(); + points.push(snapshot_timeline_point( + 0, + &RunReport::default(), + &target, + &extract_methods, + max_extract_time_secs, + rewrite_peak_before, + )); + let mut executed_rewrite_iters = 0usize; + let mut stopped_early_due_to_memory_cap = false; + for iteration in 1..rewrite_iters { + let started = Instant::now(); + let report = NncaseClampTx::run_ruleset(rs, RunConfig::Once); + let rewrite_elapsed_ms = elapsed_ms(started); + executed_rewrite_iters += 1; + let current_peak = current_peak_memory_bytes(); + let tuple_count = { + let egraph = ::egraph(); + let egraph = egraph.lock().unwrap(); + egraph.num_tuples() + }; + let rule_matches = report + .num_matches_per_rule + .iter() + .map(|(name, count)| (name.to_string(), *count)) + .collect::>(); + let extracts = extract_methods + .iter() + .map(|method| { + measure_extract_metric_with_timeout( + &target, + iteration, + method, + max_extract_time_secs, + ) + }) + .collect::>(); + points.push(RewriteTimelinePoint { + iteration, + tuple_count, + rewrite_elapsed_ms, + rewrite_peak_memory_bytes: current_peak.saturating_sub(rewrite_peak_before), + rule_matches, + extracts, + }); + if current_peak > max_rewrite_mem_bytes { + stopped_early_due_to_memory_cap = true; + break; + } + } + ExtractTimelineReport { + version_nickname: None, + benchmark_family: "nncase", + benchmark_case: "clamp", + baseline: eggplant::helpers::report::NNCASE_EGRAPH_BASELINE, + comparison_target: eggplant::helpers::report::EGGPLANT_COMPARISON_TARGET, + positioning: eggplant::helpers::report::NNCASE_EGRAPH_SLOWER_POSITIONING, + selected_extractors: extract_methods.iter().map(|m| (*m).to_string()).collect(), + max_extract_time_secs, + requested_rewrite_iters: rewrite_iters, + executed_rewrite_iters, + max_rewrite_mem_gib, + stopped_early_due_to_memory_cap, + points, + } +} + +#[cfg(feature = "rustsat-extract")] +fn snapshot_timeline_point( + iteration: usize, + report: &RunReport, + target: &N, + extract_methods: &[&'static str], + max_extract_time_secs: Option, + rewrite_peak_before: u64, +) -> RewriteTimelinePoint +where + N: EgglogNode + EgglogTy + 'static, +{ + let tuple_count = { + let egraph = ::egraph(); + let egraph = egraph.lock().unwrap(); + egraph.num_tuples() + }; + let current_peak = current_peak_memory_bytes(); + let mut rule_matches = report + .num_matches_per_rule + .iter() + .map(|(name, count)| (name.to_string(), *count)) + .collect::>(); + if rule_matches.is_empty() && iteration == 0 { + rule_matches.insert("@initial_state".to_string(), 1); + } + let extracts = extract_methods + .iter() + .map(|method| { + measure_extract_metric_with_timeout(target, iteration, method, max_extract_time_secs) + }) + .collect::>(); + RewriteTimelinePoint { + iteration, + tuple_count, + rewrite_elapsed_ms: 0.0, + rewrite_peak_memory_bytes: current_peak.saturating_sub(rewrite_peak_before), + rule_matches, + extracts, + } +} + +pub fn run_clamp_rewrite_smoke(rewrite_iters: usize, cost_model: CM) -> String +where + CM: eggplant::egglog::extract::CostModel + 'static, +{ + NncaseClampTx::reset_for_bench(); + let input = Input::::new("input".to_owned()); + input.commit(); + let weight = Weight::::new("w0".to_owned()); + weight.commit(); + let conv = Conv2D::::new(&input, &weight); + conv.commit(); + let root = Relu::::new(&conv); + root.commit(); + let rs = NncaseClampTx::new_ruleset("nncase_clamp_smoke_rules"); + register_rewrite_rules(rs); + for _ in 0..rewrite_iters { + NncaseClampTx::run_ruleset(rs, RunConfig::Once); + } + let (rendered, _) = NncaseClampTx::extract_node_to_string_with_cost_model(&root, cost_model) + .expect("smoke extract should succeed"); + rendered +} diff --git a/src/benchmarks/nncase_transpose_microbenchmark.rs b/src/benchmarks/nncase_transpose_microbenchmark.rs new file mode 100644 index 0000000..a25459b --- /dev/null +++ b/src/benchmarks/nncase_transpose_microbenchmark.rs @@ -0,0 +1,889 @@ +use egglog_reports::RunReport; +use eggplant::prelude::*; +use eggplant::tx_rx_vt_pr; +use eggplant::wrap::NonPatRecSgl; +use serde::{Deserialize, Serialize}; +use std::collections::BTreeMap; +use std::path::PathBuf; +use std::time::{Duration, Instant}; + +#[cfg(feature = "rustsat-extract")] +use eggplant::egglog::extract::TreeAdditiveCostModel; +#[cfg(feature = "rustsat-extract")] +use eggplant::wrap::EgglogTy; +#[cfg(feature = "rustsat-extract")] +use std::fs; + +#[eggplant::dsl] +enum PermTag { + #[typst("id")] + #[precedence(100)] + #[cost(0)] + PermId {}, + #[typst("sigma")] + #[precedence(100)] + #[cost(0)] + PermSwap {}, +} + +#[eggplant::dsl] +enum TransposeExpr { + #[display("{name}")] + #[typst("{name}")] + #[precedence(100)] + #[cost(0)] + TransposeInput { name: String }, + #[typst("T_{perm}({inner})")] + #[precedence(80)] + #[cost(6)] + Transpose { inner: TransposeExpr, perm: PermTag }, + #[typst("{lhs} + {rhs}")] + #[precedence(40)] + #[cost(1)] + Add { + lhs: TransposeExpr, + rhs: TransposeExpr, + }, + #[typst("exp({inner})")] + #[precedence(90)] + #[cost(2)] + UnaryExp { inner: TransposeExpr }, +} + +tx_rx_vt_pr!(NncaseTransposeTx, NncaseTransposePatRec); + +pub struct MathExtractComparisonRow { + pub method: &'static str, + pub requested_rewrite_iters: usize, + pub executed_rewrite_iters: usize, + pub max_rewrite_mem_gib: u64, + pub run_ruleset_note: String, + pub rewrite_peak_memory_bytes: u64, + pub extract_peak_memory_bytes: Option, + pub cost: Option, + pub elapsed: Option, + pub rendered: String, + pub svg_path: String, + pub timed_out: bool, +} + +#[derive(Debug, Clone)] +pub enum ProgressEvent { + RewriteIterationComplete { + current: usize, + total: usize, + tuple_count: usize, + peak_memory_bytes: u64, + }, + RewriteStoppedByMemoryCap { + current: usize, + total: usize, + peak_memory_bytes: u64, + cap_bytes: u64, + }, + ExtractPhaseStart { + method: &'static str, + current: usize, + total: usize, + }, + ExtractPhaseComplete { + method: &'static str, + current: usize, + total: usize, + elapsed_ms: f64, + peak_memory_bytes: u64, + }, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ExtractTimelineMetric { + pub method: String, + pub cost: Option, + pub elapsed_ms: Option, + pub peak_memory_bytes: Option, + pub svg_path: String, + pub timed_out: bool, +} + +#[derive(Debug, Clone, Serialize)] +pub struct RewriteTimelinePoint { + pub iteration: usize, + pub tuple_count: usize, + pub rewrite_elapsed_ms: f64, + pub rewrite_peak_memory_bytes: u64, + pub rule_matches: BTreeMap, + pub extracts: Vec, +} + +#[derive(Debug, Clone, Serialize)] +pub struct ExtractTimelineReport { + pub version_nickname: Option, + pub benchmark_family: &'static str, + pub benchmark_case: &'static str, + pub baseline: &'static str, + pub comparison_target: &'static str, + pub positioning: &'static str, + pub selected_extractors: Vec, + pub max_extract_time_secs: Option, + pub requested_rewrite_iters: usize, + pub executed_rewrite_iters: usize, + pub max_rewrite_mem_gib: u64, + pub stopped_early_due_to_memory_cap: bool, + pub points: Vec, +} + +pub struct NncaseTransposeStats { + pub total_num_tuples: usize, + pub max_rewrite_mem_gib: u64, + pub rewrite_peak_memory_bytes: u64, + pub requested_rewrite_iters: usize, + pub executed_rewrite_iters: usize, + pub rewrite_stopped_early_due_to_memory_cap: bool, +} + +#[cfg(feature = "rustsat-extract")] +const ALL_EXTRACT_METHODS: &[&str] = &["default", "eboost", "layered", "rustsat"]; + +const DEFAULT_RUN_RULESET_MEMORY_CAP_GIB: u64 = 20; + +const OP_COSTS: &[(&str, u64)] = &[ + ("Input", 0), + ("PermId", 0), + ("PermSwap", 0), + ("Add", 1), + ("UnaryExp", 2), + ("Transpose", 6), +]; + +const REWRITE_RULES: &[&str] = &[ + "combine_binary_transpose", + "combine_unary_transpose", + "fold_two_transposes", + "fold_nop_transpose", +]; + +const RULE_WITNESSES: &[(&str, &str)] = &[ + ( + "combine_binary_transpose", + "Add(Transpose(lhs, swap), Transpose(UnaryExp(rhs), swap))", + ), + ("combine_unary_transpose", "UnaryExp(Transpose(aux, swap))"), + ( + "fold_two_transposes", + "Transpose(Transpose(aux, swap), swap)", + ), + ("fold_nop_transpose", "Transpose(aux, id)"), +]; + +pub fn workload_spec() -> eggplant::helpers::report::BenchmarkWorkloadSpec<'static> { + eggplant::helpers::report::BenchmarkWorkloadSpec { + positioning: eggplant::helpers::report::nncase_benchmark_positioning("transpose"), + op_costs: OP_COSTS, + target_root: "Transpose(Add(Transpose(lhs, swap), Transpose(UnaryExp(rhs), swap)), swap)", + rewrite_rules: REWRITE_RULES, + rule_witnesses: RULE_WITNESSES, + } +} + +pub type ExtractCliArgs = eggplant::helpers::bench_cli::ExtractBenchCliArgs; +pub type TimelineCliArgs = eggplant::helpers::bench_cli::TimelineExportCliArgs; + +pub fn parse_extract_args(args: I) -> ExtractCliArgs +where + I: IntoIterator, + T: Into + Clone, +{ + eggplant::helpers::bench_cli::parse_extract_bench_args( + "nncase_transpose_extract_bench", + "Run the nncase transpose microbenchmark with CLI progress bars", + 8, + DEFAULT_RUN_RULESET_MEMORY_CAP_GIB, + args, + ) +} + +pub fn parse_timeline_args(args: I) -> TimelineCliArgs +where + I: IntoIterator, + T: Into + Clone, +{ + eggplant::helpers::bench_cli::parse_timeline_export_args( + "nncase_transpose_timeline_export", + "Export nncase transpose timeline data with CLI progress bars", + 8, + 12, + "target/nncase_transpose_timeline.json", + args, + ) +} + +fn register_rewrite_rules(rs: RuleSetId) { + NncaseTransposeTx::add_rule( + "combine_binary_transpose", + rs, + || { + let lhs = TransposeExpr::query_leaf(); + let rhs = TransposeExpr::query_leaf(); + let perm = PermTag::query_leaf(); + let lhs_t = Transpose::query(&lhs, &perm); + let rhs_t = Transpose::query(&rhs, &perm); + let add = Add::query(&lhs_t, &rhs_t); + #[eggplant::pat_vars] + struct Pat { + lhs: TransposeExpr, + rhs: TransposeExpr, + perm: PermTag, + add: Add, + } + Pat::new(lhs, rhs, perm, add) + }, + |ctx, pat| { + let pushed_add = ctx.insert_add(pat.lhs, pat.rhs); + let rhs = ctx.insert_transpose(pushed_add, pat.perm); + ctx.union(pat.add, rhs); + }, + ); + + NncaseTransposeTx::add_rule( + "combine_unary_transpose", + rs, + || { + let inner = TransposeExpr::query_leaf(); + let perm = PermTag::query_leaf(); + let t = Transpose::query(&inner, &perm); + let exp = UnaryExp::query(&t); + #[eggplant::pat_vars] + struct Pat { + inner: TransposeExpr, + perm: PermTag, + exp: UnaryExp, + } + Pat::new(inner, perm, exp) + }, + |ctx, pat| { + let inner_exp = ctx.insert_unary_exp(pat.inner); + let rhs = ctx.insert_transpose(inner_exp, pat.perm); + ctx.union(pat.exp, rhs); + }, + ); + + NncaseTransposeTx::add_rule( + "fold_two_transposes", + rs, + || { + let inner = TransposeExpr::query_leaf(); + let perm = PermSwap::query(); + let t1 = Transpose::query(&inner, &perm); + let t2 = Transpose::query(&t1, &perm); + #[eggplant::pat_vars] + struct Pat { + inner: TransposeExpr, + t2: Transpose, + } + Pat::new(inner, t2) + }, + |ctx, pat| { + ctx.union(pat.t2, pat.inner); + }, + ); + + NncaseTransposeTx::add_rule( + "fold_nop_transpose", + rs, + || { + let inner = TransposeExpr::query_leaf(); + let perm = PermId::query(); + let t = Transpose::query(&inner, &perm); + #[eggplant::pat_vars] + struct Pat { + inner: TransposeExpr, + t: Transpose, + } + Pat::new(inner, t) + }, + |ctx, pat| { + ctx.union(pat.t, pat.inner); + }, + ); +} + +fn seed_domain(seed_name: &'static str) { + let seed = NncaseTransposeTx::new_ruleset(seed_name); + NncaseTransposeTx::add_rule( + seed_name, + seed, + || { + #[eggplant::pat_vars_catch] + struct Unit {} + }, + |ctx, _pat| { + let lhs = ctx.insert_transpose_input("lhs".to_owned()); + let rhs = ctx.insert_transpose_input("rhs".to_owned()); + let aux = ctx.insert_transpose_input("aux".to_owned()); + let swap = ctx.insert_perm_swap(); + let id = ctx.insert_perm_id(); + + let lhs_t = ctx.insert_transpose(lhs, swap); + let rhs_exp = ctx.insert_unary_exp(rhs); + let rhs_t = ctx.insert_transpose(rhs_exp, swap); + let add = ctx.insert_add(lhs_t, rhs_t); + ctx.insert_transpose(add, swap); + + let aux_id = ctx.insert_transpose(aux, id); + ctx.insert_unary_exp(aux_id); + let aux_swap = ctx.insert_transpose(aux, swap); + ctx.insert_unary_exp(aux_swap); + ctx.insert_transpose(aux_swap, swap); + }, + ); + NncaseTransposeTx::run_ruleset(seed, RunConfig::Once); +} + +pub fn run_and_collect_stats_iters_with_mem_cap_and_progress( + rewrite_iters: usize, + max_rewrite_mem_gib: u64, + mut on_progress: F, +) -> NncaseTransposeStats +where + F: FnMut(ProgressEvent), +{ + let max_rewrite_mem_bytes = gib_to_bytes(max_rewrite_mem_gib); + + NncaseTransposeTx::reset_for_bench(); + seed_domain("nncase_transpose_seed"); + + let rs = NncaseTransposeTx::new_ruleset("nncase_transpose_rules"); + register_rewrite_rules(rs); + + let rewrite_peak_before = current_peak_memory_bytes(); + let mut executed_rewrite_iters = 0usize; + let mut rewrite_stopped_early_due_to_memory_cap = false; + for _ in 0..rewrite_iters { + NncaseTransposeTx::run_ruleset(rs, RunConfig::Once); + let current_peak = current_peak_memory_bytes(); + let tuple_count = { + let egraph = ::egraph(); + let egraph = egraph.lock().unwrap(); + egraph.num_tuples() + }; + on_progress(ProgressEvent::RewriteIterationComplete { + current: executed_rewrite_iters + 1, + total: rewrite_iters, + tuple_count, + peak_memory_bytes: current_peak, + }); + executed_rewrite_iters += 1; + if current_peak > max_rewrite_mem_bytes { + rewrite_stopped_early_due_to_memory_cap = true; + on_progress(ProgressEvent::RewriteStoppedByMemoryCap { + current: executed_rewrite_iters, + total: rewrite_iters, + peak_memory_bytes: current_peak, + cap_bytes: max_rewrite_mem_bytes, + }); + break; + } + } + let rewrite_peak_after = current_peak_memory_bytes(); + let rewrite_peak_memory_bytes = rewrite_peak_after.saturating_sub(rewrite_peak_before); + let egraph = ::egraph(); + let egraph = egraph.lock().unwrap(); + NncaseTransposeStats { + total_num_tuples: egraph.num_tuples(), + max_rewrite_mem_gib, + rewrite_peak_memory_bytes, + requested_rewrite_iters: rewrite_iters, + executed_rewrite_iters, + rewrite_stopped_early_due_to_memory_cap, + } +} + +#[cfg(feature = "rustsat-extract")] +fn build_extract_target() -> impl EgglogNode + EgglogTy + 'static { + let lhs = TransposeInput::::new("lhs".to_owned()); + lhs.commit(); + let rhs = TransposeInput::::new("rhs".to_owned()); + rhs.commit(); + let swap = PermSwap::::new(); + swap.commit(); + + let lhs_t = Transpose::::new(&lhs, &swap); + lhs_t.commit(); + let rhs_exp = UnaryExp::::new(&rhs); + rhs_exp.commit(); + let rhs_t = Transpose::::new(&rhs_exp, &swap); + rhs_t.commit(); + let add = Add::::new(&lhs_t, &rhs_t); + add.commit(); + let root = Transpose::::new(&add, &swap); + root.commit(); + root +} + +#[cfg(feature = "rustsat-extract")] +fn extract_backend_for_method(method: &'static str) -> ExtractBackend { + match method { + "default" => ExtractBackend::cost_model(TreeAdditiveCostModel::default()), + "eboost" => { + ExtractBackend::::eboost_heuristic(EBoostExtractConfig::default()) + } + "layered" => { + ExtractBackend::::eboost_layered(EBoostLayeredConfig::default()) + } + "rustsat" => { + ExtractBackend::::rustsat(RustsatExtractConfig::default()) + } + other => panic!("unsupported extract method `{other}`"), + } +} + +#[cfg(feature = "rustsat-extract")] +fn parse_extract_methods(methods: &[String]) -> Vec<&'static str> { + if methods.is_empty() { + return ALL_EXTRACT_METHODS.to_vec(); + } + methods + .iter() + .map(|method| match method.as_str() { + "default" => "default", + "eboost" => "eboost", + "layered" => "layered", + "rustsat" => "rustsat", + other => panic!("unsupported extract method `{other}`"), + }) + .collect() +} + +#[cfg(feature = "rustsat-extract")] +fn render_svg_for_method(target: &N, method: &'static str, svg_path: &PathBuf) -> u64 +where + N: EgglogNode + EgglogTy + 'static, +{ + NncaseTransposeTx::extract_node_to_svg_with_backend( + target, + extract_backend_for_method(method), + svg_path, + ) + .expect("svg rendering should succeed") +} + +#[cfg(feature = "rustsat-extract")] +fn benchmark_extract_backend( + target: &N, + method: &'static str, + rewrite_peak_memory_bytes: u64, +) -> MathExtractComparisonRow +where + N: EgglogNode + EgglogTy + 'static, +{ + let extract_peak_before = current_peak_memory_bytes(); + let started = Instant::now(); + let (rendered, cost) = NncaseTransposeTx::extract_node_to_string_with_backend( + target, + extract_backend_for_method(method), + ) + .expect("transpose extraction should succeed"); + let svg_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("target") + .join("nncase_transpose_extract_svgs"); + fs::create_dir_all(&svg_dir).expect("svg output directory should be creatable"); + let svg_path = svg_dir.join(format!("{method}.svg")); + let _ = render_svg_for_method(target, method, &svg_path); + let extract_peak_after = current_peak_memory_bytes(); + MathExtractComparisonRow { + method, + requested_rewrite_iters: 0, + executed_rewrite_iters: 0, + max_rewrite_mem_gib: 0, + run_ruleset_note: String::new(), + rewrite_peak_memory_bytes, + extract_peak_memory_bytes: Some(extract_peak_after.saturating_sub(extract_peak_before)), + cost: Some(cost), + elapsed: Some(started.elapsed()), + rendered, + svg_path: svg_path.display().to_string(), + timed_out: false, + } +} + +#[cfg(feature = "rustsat-extract")] +#[derive(Debug, Clone, Serialize, Deserialize)] +struct TimedExtractComparisonPayload { + rendered: String, + cost: u64, + elapsed_ms: f64, + peak_memory_bytes: u64, + svg_path: String, +} + +fn benchmark_extract_backend_with_timeout( + target: &N, + method: &'static str, + rewrite_peak_memory_bytes: u64, + max_extract_time_secs: Option, +) -> MathExtractComparisonRow +where + N: EgglogNode + EgglogTy + 'static, +{ + let payload = run_with_timeout_payload( + max_extract_time_secs, + || { + let row = benchmark_extract_backend(target, method, rewrite_peak_memory_bytes); + TimedExtractComparisonPayload { + rendered: row.rendered, + cost: row.cost.unwrap_or(0), + elapsed_ms: row.elapsed.map(duration_to_ms).unwrap_or(0.0), + peak_memory_bytes: row.extract_peak_memory_bytes.unwrap_or(0), + svg_path: row.svg_path, + } + }, + || TimedExtractComparisonPayload { + rendered: "NaN".to_string(), + cost: 0, + elapsed_ms: f64::NAN, + peak_memory_bytes: 0, + svg_path: "n/a".to_string(), + }, + ); + + if payload.elapsed_ms.is_nan() { + timeout_row(method, rewrite_peak_memory_bytes) + } else { + MathExtractComparisonRow { + method, + requested_rewrite_iters: 0, + executed_rewrite_iters: 0, + max_rewrite_mem_gib: 0, + run_ruleset_note: String::new(), + rewrite_peak_memory_bytes, + extract_peak_memory_bytes: Some(payload.peak_memory_bytes), + cost: Some(payload.cost), + elapsed: Some(duration_from_ms(payload.elapsed_ms)), + rendered: payload.rendered, + svg_path: payload.svg_path, + timed_out: false, + } + } +} + +#[cfg(feature = "rustsat-extract")] +fn timeout_row(method: &'static str, rewrite_peak_memory_bytes: u64) -> MathExtractComparisonRow { + MathExtractComparisonRow { + method, + requested_rewrite_iters: 0, + executed_rewrite_iters: 0, + max_rewrite_mem_gib: 0, + run_ruleset_note: String::new(), + rewrite_peak_memory_bytes, + extract_peak_memory_bytes: None, + cost: None, + elapsed: None, + rendered: "NaN".to_string(), + svg_path: "n/a".to_string(), + timed_out: true, + } +} + +#[cfg(feature = "rustsat-extract")] +fn measure_extract_metric( + target: &N, + iteration: usize, + method: &'static str, +) -> ExtractTimelineMetric +where + N: EgglogNode + EgglogTy + 'static, +{ + let extract_peak_before = current_peak_memory_bytes(); + let started = Instant::now(); + let (_rendered, cost) = NncaseTransposeTx::extract_node_to_string_with_backend( + target, + extract_backend_for_method(method), + ) + .expect("timeline extract should succeed"); + let elapsed_ms = elapsed_ms(started); + let svg_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("target") + .join("nncase_transpose_timeline_svgs") + .join(format!("iter_{iteration:03}")); + fs::create_dir_all(&svg_dir).expect("timeline svg output directory should be creatable"); + let svg_path = svg_dir.join(format!("{method}.svg")); + let _ = render_svg_for_method(target, method, &svg_path); + let extract_peak_after = current_peak_memory_bytes(); + ExtractTimelineMetric { + method: method.to_string(), + cost: Some(cost), + elapsed_ms: Some(elapsed_ms), + peak_memory_bytes: Some(extract_peak_after.saturating_sub(extract_peak_before)), + svg_path: svg_path.display().to_string(), + timed_out: false, + } +} + +fn measure_extract_metric_with_timeout( + target: &N, + iteration: usize, + method: &'static str, + max_extract_time_secs: Option, +) -> ExtractTimelineMetric +where + N: EgglogNode + EgglogTy + 'static, +{ + run_with_timeout_payload( + max_extract_time_secs, + || measure_extract_metric(target, iteration, method), + || ExtractTimelineMetric { + method: method.to_string(), + cost: None, + elapsed_ms: None, + peak_memory_bytes: None, + svg_path: "n/a".to_string(), + timed_out: true, + }, + ) +} + +#[cfg(feature = "rustsat-extract")] +pub fn run_extract_comparison_with_iters_and_mem_cap( + rewrite_iters: usize, + max_rewrite_mem_gib: u64, +) -> Vec { + run_extract_comparison_with_options_and_progress( + rewrite_iters, + max_rewrite_mem_gib, + &[], + None, + |_| {}, + ) +} + +#[cfg(feature = "rustsat-extract")] +pub fn run_extract_comparison_with_options_and_progress( + rewrite_iters: usize, + max_rewrite_mem_gib: u64, + selected_extractors: &[String], + max_extract_time_secs: Option, + mut on_progress: F, +) -> Vec +where + F: FnMut(ProgressEvent), +{ + let extract_methods = parse_extract_methods(selected_extractors); + let stats = run_and_collect_stats_iters_with_mem_cap_and_progress( + rewrite_iters, + max_rewrite_mem_gib, + |event| on_progress(event), + ); + let target = build_extract_target(); + + let mut rows = Vec::new(); + for (index, method) in extract_methods.iter().enumerate() { + on_progress(ProgressEvent::ExtractPhaseStart { + method, + current: index + 1, + total: extract_methods.len(), + }); + let mut row = benchmark_extract_backend_with_timeout( + &target, + method, + stats.rewrite_peak_memory_bytes, + max_extract_time_secs, + ); + row.requested_rewrite_iters = stats.requested_rewrite_iters; + row.executed_rewrite_iters = stats.executed_rewrite_iters; + row.max_rewrite_mem_gib = stats.max_rewrite_mem_gib; + row.run_ruleset_note = if stats.rewrite_stopped_early_due_to_memory_cap { + format!( + "stopped early at {} / {} iterations because peak memory exceeded {} GiB", + stats.executed_rewrite_iters, + stats.requested_rewrite_iters, + stats.max_rewrite_mem_gib + ) + } else { + "completed requested iterations".to_string() + }; + on_progress(ProgressEvent::ExtractPhaseComplete { + method, + current: index + 1, + total: extract_methods.len(), + elapsed_ms: row.elapsed.map(duration_to_ms).unwrap_or(f64::NAN), + peak_memory_bytes: row.extract_peak_memory_bytes.unwrap_or(0), + }); + rows.push(row); + } + rows +} + +#[cfg(feature = "rustsat-extract")] +pub fn run_extract_timeline_with_iters_and_mem_cap( + rewrite_iters: usize, + max_rewrite_mem_gib: u64, +) -> ExtractTimelineReport { + run_extract_timeline_with_options(rewrite_iters, max_rewrite_mem_gib, &[], None) +} + +#[cfg(feature = "rustsat-extract")] +pub fn run_extract_timeline_with_options( + rewrite_iters: usize, + max_rewrite_mem_gib: u64, + selected_extractors: &[String], + max_extract_time_secs: Option, +) -> ExtractTimelineReport { + let max_rewrite_mem_bytes = gib_to_bytes(max_rewrite_mem_gib); + let extract_methods = parse_extract_methods(selected_extractors); + + NncaseTransposeTx::reset_for_bench(); + seed_domain("nncase_transpose_timeline_seed"); + let rs = NncaseTransposeTx::new_ruleset("nncase_transpose_timeline_rules"); + register_rewrite_rules(rs); + let target = build_extract_target(); + + let mut points = Vec::new(); + let mut executed_rewrite_iters = 0usize; + let mut stopped_early_due_to_memory_cap = false; + let rewrite_peak_before = current_peak_memory_bytes(); + + points.push(snapshot_timeline_point( + 0, + &RunReport::default(), + &target, + &extract_methods, + max_extract_time_secs, + rewrite_peak_before, + )); + + for iteration in 1..rewrite_iters { + let started = Instant::now(); + let report = NncaseTransposeTx::run_ruleset(rs, RunConfig::Once); + let rewrite_elapsed_ms = elapsed_ms(started); + executed_rewrite_iters += 1; + let current_peak = current_peak_memory_bytes(); + let tuple_count = { + let egraph = ::egraph(); + let egraph = egraph.lock().unwrap(); + egraph.num_tuples() + }; + let rule_matches = report + .num_matches_per_rule + .iter() + .map(|(name, count)| (name.to_string(), *count)) + .collect::>(); + let extracts = extract_methods + .iter() + .map(|method| { + measure_extract_metric_with_timeout( + &target, + iteration, + method, + max_extract_time_secs, + ) + }) + .collect::>(); + points.push(RewriteTimelinePoint { + iteration, + tuple_count, + rewrite_elapsed_ms, + rewrite_peak_memory_bytes: current_peak.saturating_sub(rewrite_peak_before), + rule_matches, + extracts, + }); + if current_peak > max_rewrite_mem_bytes { + stopped_early_due_to_memory_cap = true; + break; + } + } + + ExtractTimelineReport { + version_nickname: None, + benchmark_family: "nncase", + benchmark_case: "transpose", + baseline: eggplant::helpers::report::NNCASE_EGRAPH_BASELINE, + comparison_target: eggplant::helpers::report::EGGPLANT_COMPARISON_TARGET, + positioning: eggplant::helpers::report::NNCASE_EGRAPH_SLOWER_POSITIONING, + selected_extractors: extract_methods.iter().map(|m| (*m).to_string()).collect(), + max_extract_time_secs, + requested_rewrite_iters: rewrite_iters, + executed_rewrite_iters, + max_rewrite_mem_gib, + stopped_early_due_to_memory_cap, + points, + } +} + +#[cfg(feature = "rustsat-extract")] +fn snapshot_timeline_point( + iteration: usize, + report: &RunReport, + target: &N, + extract_methods: &[&'static str], + max_extract_time_secs: Option, + rewrite_peak_before: u64, +) -> RewriteTimelinePoint +where + N: EgglogNode + EgglogTy + 'static, +{ + let tuple_count = { + let egraph = ::egraph(); + let egraph = egraph.lock().unwrap(); + egraph.num_tuples() + }; + let current_peak = current_peak_memory_bytes(); + let mut rule_matches = report + .num_matches_per_rule + .iter() + .map(|(name, count)| (name.to_string(), *count)) + .collect::>(); + if rule_matches.is_empty() && iteration == 0 { + rule_matches.insert("@initial_state".to_string(), 1); + } + let extracts = extract_methods + .iter() + .map(|method| { + measure_extract_metric_with_timeout(target, iteration, method, max_extract_time_secs) + }) + .collect::>(); + RewriteTimelinePoint { + iteration, + tuple_count, + rewrite_elapsed_ms: 0.0, + rewrite_peak_memory_bytes: current_peak.saturating_sub(rewrite_peak_before), + rule_matches, + extracts, + } +} + +pub fn run_transpose_rewrite_smoke(rewrite_iters: usize, cost_model: CM) -> String +where + CM: eggplant::egglog::extract::CostModel + 'static, +{ + NncaseTransposeTx::reset_for_bench(); + + let lhs = TransposeInput::::new("lhs".to_owned()); + lhs.commit(); + let rhs = TransposeInput::::new("rhs".to_owned()); + rhs.commit(); + let swap = PermSwap::::new(); + swap.commit(); + + let lhs_t = Transpose::::new(&lhs, &swap); + lhs_t.commit(); + let rhs_exp = UnaryExp::::new(&rhs); + rhs_exp.commit(); + let rhs_t = Transpose::::new(&rhs_exp, &swap); + rhs_t.commit(); + let add = Add::::new(&lhs_t, &rhs_t); + add.commit(); + let root = Transpose::::new(&add, &swap); + root.commit(); + + let rs = NncaseTransposeTx::new_ruleset("nncase_transpose_smoke_rules"); + register_rewrite_rules(rs); + + for _ in 0..rewrite_iters { + NncaseTransposeTx::run_ruleset(rs, RunConfig::Once); + } + + let (rendered, _) = + NncaseTransposeTx::extract_node_to_string_with_cost_model(&root, cost_model) + .expect("smoke extract should succeed"); + rendered +} diff --git a/src/benchmarks/nncase_vectorize_microbenchmark.rs b/src/benchmarks/nncase_vectorize_microbenchmark.rs new file mode 100644 index 0000000..9dd57fe --- /dev/null +++ b/src/benchmarks/nncase_vectorize_microbenchmark.rs @@ -0,0 +1,876 @@ +use egglog_reports::RunReport; +use eggplant::prelude::*; +use eggplant::tx_rx_vt_pr; +use eggplant::wrap::NonPatRecSgl; +use serde::{Deserialize, Serialize}; +use std::collections::BTreeMap; +use std::path::PathBuf; +use std::time::{Duration, Instant}; + +#[cfg(feature = "rustsat-extract")] +use eggplant::egglog::extract::TreeAdditiveCostModel; +#[cfg(feature = "rustsat-extract")] +use eggplant::wrap::EgglogTy; +#[cfg(feature = "rustsat-extract")] +use std::fs; + +#[eggplant::dsl] +enum LayoutTag { + #[typst("f")] + #[precedence(100)] + #[cost(0)] + Flat {}, + #[typst("b")] + #[precedence(100)] + #[cost(0)] + Blocked {}, +} + +#[eggplant::dsl] +enum VectorizeExpr { + #[display("{name}")] + #[typst("{name}")] + #[precedence(100)] + #[cost(0)] + VectorizeInput { name: String }, + #[typst("({lhs} * {rhs})")] + #[precedence(50)] + #[cost(12)] + LogicalMatMul { + lhs: VectorizeExpr, + rhs: VectorizeExpr, + }, + #[typst("e^({inner})")] + #[precedence(90)] + #[cost(6)] + LogicalExp { inner: VectorizeExpr }, + #[typst("({inner})_({layout})")] + #[precedence(90)] + #[cost(3)] + Pack { + inner: VectorizeExpr, + layout: LayoutTag, + }, + #[typst("({inner})^({layout})")] + #[precedence(90)] + #[cost(3)] + Unpack { + inner: VectorizeExpr, + layout: LayoutTag, + }, + #[typst("(({lhs} * {rhs}))_({layout})")] + #[precedence(50)] + #[cost(2)] + PackedMatMul { + lhs: VectorizeExpr, + rhs: VectorizeExpr, + layout: LayoutTag, + }, + #[typst("(e^({inner}))_({layout})")] + #[precedence(90)] + #[cost(1)] + PackedExp { + inner: VectorizeExpr, + layout: LayoutTag, + }, +} + +tx_rx_vt_pr!(NncaseVectorizeTx, NncaseVectorizePatRec); + +pub struct MathExtractComparisonRow { + pub method: &'static str, + pub requested_rewrite_iters: usize, + pub executed_rewrite_iters: usize, + pub max_rewrite_mem_gib: u64, + pub run_ruleset_note: String, + pub rewrite_peak_memory_bytes: u64, + pub extract_peak_memory_bytes: Option, + pub cost: Option, + pub elapsed: Option, + pub rendered: String, + pub svg_path: String, + pub timed_out: bool, +} + +#[derive(Debug, Clone)] +pub enum ProgressEvent { + RewriteIterationComplete { + current: usize, + total: usize, + tuple_count: usize, + peak_memory_bytes: u64, + }, + RewriteStoppedByMemoryCap { + current: usize, + total: usize, + peak_memory_bytes: u64, + cap_bytes: u64, + }, + ExtractPhaseStart { + method: &'static str, + current: usize, + total: usize, + }, + ExtractPhaseComplete { + method: &'static str, + current: usize, + total: usize, + elapsed_ms: f64, + peak_memory_bytes: u64, + }, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ExtractTimelineMetric { + pub method: String, + pub cost: Option, + pub elapsed_ms: Option, + pub peak_memory_bytes: Option, + pub svg_path: String, + pub timed_out: bool, +} + +#[derive(Debug, Clone, Serialize)] +pub struct RewriteTimelinePoint { + pub iteration: usize, + pub tuple_count: usize, + pub rewrite_elapsed_ms: f64, + pub rewrite_peak_memory_bytes: u64, + pub rule_matches: BTreeMap, + pub extracts: Vec, +} + +#[derive(Debug, Clone, Serialize)] +pub struct ExtractTimelineReport { + pub version_nickname: Option, + pub benchmark_family: &'static str, + pub benchmark_case: &'static str, + pub baseline: &'static str, + pub comparison_target: &'static str, + pub positioning: &'static str, + pub selected_extractors: Vec, + pub max_extract_time_secs: Option, + pub requested_rewrite_iters: usize, + pub executed_rewrite_iters: usize, + pub max_rewrite_mem_gib: u64, + pub stopped_early_due_to_memory_cap: bool, + pub points: Vec, +} + +pub struct NncaseVectorizeStats { + pub max_rewrite_mem_gib: u64, + pub rewrite_peak_memory_bytes: u64, + pub requested_rewrite_iters: usize, + pub executed_rewrite_iters: usize, + pub rewrite_stopped_early_due_to_memory_cap: bool, +} + +#[cfg(feature = "rustsat-extract")] +const ALL_EXTRACT_METHODS: &[&str] = &["default", "eboost", "layered", "rustsat"]; + +const OP_COSTS: &[(&str, u64)] = &[ + ("Input", 0), + ("Flat", 0), + ("Blocked", 0), + ("LogicalMatMul", 12), + ("LogicalExp", 6), + ("Pack", 3), + ("Unpack", 3), + ("PackedMatMul", 2), + ("PackedExp", 1), +]; + +const REWRITE_RULES: &[&str] = &[ + "meta_pack_matmul", + "meta_pack_exp", + "fold_nop_pack", + "fold_nop_unpack", +]; + +const RULE_WITNESSES: &[(&str, &str)] = &[ + ("meta_pack_matmul", "LogicalMatMul(q, k)"), + ("meta_pack_exp", "LogicalExp(Unpack(q, blocked))"), + ("fold_nop_pack", "Pack(Unpack(v, blocked), blocked)"), + ("fold_nop_unpack", "Unpack(Pack(k, blocked), blocked)"), +]; + +pub fn workload_spec() -> eggplant::helpers::report::BenchmarkWorkloadSpec<'static> { + eggplant::helpers::report::BenchmarkWorkloadSpec { + positioning: eggplant::helpers::report::nncase_benchmark_positioning("vectorize"), + op_costs: OP_COSTS, + target_root: "LogicalMatMul(LogicalExp(LogicalMatMul(q, k)), v)", + rewrite_rules: REWRITE_RULES, + rule_witnesses: RULE_WITNESSES, + } +} + +pub type ExtractCliArgs = eggplant::helpers::bench_cli::ExtractBenchCliArgs; +pub type TimelineCliArgs = eggplant::helpers::bench_cli::TimelineExportCliArgs; + +pub fn parse_extract_args(args: I) -> ExtractCliArgs +where + I: IntoIterator, + T: Into + Clone, +{ + eggplant::helpers::bench_cli::parse_extract_bench_args( + "nncase_vectorize_extract_bench", + "Run the nncase vectorize microbenchmark with CLI progress bars", + 8, + 20, + args, + ) +} + +pub fn parse_timeline_args(args: I) -> TimelineCliArgs +where + I: IntoIterator, + T: Into + Clone, +{ + eggplant::helpers::bench_cli::parse_timeline_export_args( + "nncase_vectorize_timeline_export", + "Export nncase vectorize timeline data with CLI progress bars", + 8, + 12, + "target/nncase_vectorize_timeline.json", + args, + ) +} + +fn register_rewrite_rules(rs: RuleSetId) { + NncaseVectorizeTx::add_rule( + "meta_pack_matmul", + rs, + || { + let lhs = VectorizeExpr::query_leaf(); + let rhs = VectorizeExpr::query_leaf(); + let mm = LogicalMatMul::query(&lhs, &rhs); + #[eggplant::pat_vars] + struct Pat { + lhs: VectorizeExpr, + rhs: VectorizeExpr, + mm: LogicalMatMul, + } + Pat::new(lhs, rhs, mm) + }, + |ctx, pat| { + let blocked = ctx.insert_blocked(); + let lhs_pack = ctx.insert_pack(pat.lhs, blocked); + let rhs_pack = ctx.insert_pack(pat.rhs, blocked); + let packed = ctx.insert_packed_mat_mul(lhs_pack, rhs_pack, blocked); + let rhs = ctx.insert_unpack(packed, blocked); + ctx.union(pat.mm, rhs); + }, + ); + + NncaseVectorizeTx::add_rule( + "meta_pack_exp", + rs, + || { + let inner = VectorizeExpr::query_leaf(); + let layout = LayoutTag::query_leaf(); + let unpack = Unpack::query(&inner, &layout); + let exp = LogicalExp::query(&unpack); + #[eggplant::pat_vars] + struct Pat { + inner: VectorizeExpr, + layout: LayoutTag, + exp: LogicalExp, + } + Pat::new(inner, layout, exp) + }, + |ctx, pat| { + let packed = ctx.insert_packed_exp(pat.inner, pat.layout); + let rhs = ctx.insert_unpack(packed, pat.layout); + ctx.union(pat.exp, rhs); + }, + ); + + NncaseVectorizeTx::add_rule( + "fold_nop_pack", + rs, + || { + let inner = VectorizeExpr::query_leaf(); + let layout = LayoutTag::query_leaf(); + let unpack = Unpack::query(&inner, &layout); + let pack = Pack::query(&unpack, &layout); + #[eggplant::pat_vars] + struct Pat { + inner: VectorizeExpr, + pack: Pack, + } + Pat::new(inner, pack) + }, + |ctx, pat| { + ctx.union(pat.pack, pat.inner); + }, + ); + + NncaseVectorizeTx::add_rule( + "fold_nop_unpack", + rs, + || { + let inner = VectorizeExpr::query_leaf(); + let layout = LayoutTag::query_leaf(); + let pack = Pack::query(&inner, &layout); + let unpack = Unpack::query(&pack, &layout); + #[eggplant::pat_vars] + struct Pat { + inner: VectorizeExpr, + unpack: Unpack, + } + Pat::new(inner, unpack) + }, + |ctx, pat| { + ctx.union(pat.unpack, pat.inner); + }, + ); +} + +fn seed_domain(seed_name: &'static str) { + let seed = NncaseVectorizeTx::new_ruleset(seed_name); + NncaseVectorizeTx::add_rule( + seed_name, + seed, + || { + #[eggplant::pat_vars_catch] + struct Unit {} + }, + |ctx, _pat| { + let q = ctx.insert_vectorize_input("q".to_owned()); + let k = ctx.insert_vectorize_input("k".to_owned()); + let v = ctx.insert_vectorize_input("v".to_owned()); + let blocked = ctx.insert_blocked(); + let inner_mm = ctx.insert_logical_mat_mul(q, k); + let exp = ctx.insert_logical_exp(inner_mm); + ctx.insert_logical_mat_mul(exp, v); + let unpacked_q = ctx.insert_unpack(q, blocked); + ctx.insert_logical_exp(unpacked_q); + let packed_k = ctx.insert_pack(k, blocked); + ctx.insert_unpack(packed_k, blocked); + let unpacked_v = ctx.insert_unpack(v, blocked); + ctx.insert_pack(unpacked_v, blocked); + }, + ); + NncaseVectorizeTx::run_ruleset(seed, RunConfig::Once); +} + +pub fn run_and_collect_stats_iters_with_mem_cap_and_progress( + rewrite_iters: usize, + max_rewrite_mem_gib: u64, + mut on_progress: F, +) -> NncaseVectorizeStats +where + F: FnMut(ProgressEvent), +{ + let max_rewrite_mem_bytes = gib_to_bytes(max_rewrite_mem_gib); + NncaseVectorizeTx::reset_for_bench(); + seed_domain("nncase_vectorize_seed"); + let rs = NncaseVectorizeTx::new_ruleset("nncase_vectorize_rules"); + register_rewrite_rules(rs); + let rewrite_peak_before = current_peak_memory_bytes(); + let mut executed_rewrite_iters = 0usize; + let mut rewrite_stopped_early_due_to_memory_cap = false; + for _ in 0..rewrite_iters { + NncaseVectorizeTx::run_ruleset(rs, RunConfig::Once); + let current_peak = current_peak_memory_bytes(); + let tuple_count = { + let egraph = ::egraph(); + let egraph = egraph.lock().unwrap(); + egraph.num_tuples() + }; + executed_rewrite_iters += 1; + on_progress(ProgressEvent::RewriteIterationComplete { + current: executed_rewrite_iters, + total: rewrite_iters, + tuple_count, + peak_memory_bytes: current_peak, + }); + if current_peak > max_rewrite_mem_bytes { + rewrite_stopped_early_due_to_memory_cap = true; + on_progress(ProgressEvent::RewriteStoppedByMemoryCap { + current: executed_rewrite_iters, + total: rewrite_iters, + peak_memory_bytes: current_peak, + cap_bytes: max_rewrite_mem_bytes, + }); + break; + } + } + let rewrite_peak_after = current_peak_memory_bytes(); + NncaseVectorizeStats { + max_rewrite_mem_gib, + rewrite_peak_memory_bytes: rewrite_peak_after.saturating_sub(rewrite_peak_before), + requested_rewrite_iters: rewrite_iters, + executed_rewrite_iters, + rewrite_stopped_early_due_to_memory_cap, + } +} + +#[cfg(feature = "rustsat-extract")] +fn build_extract_target() -> impl EgglogNode + EgglogTy + 'static { + let q = VectorizeInput::::new("q".to_owned()); + q.commit(); + let k = VectorizeInput::::new("k".to_owned()); + k.commit(); + let v = VectorizeInput::::new("v".to_owned()); + v.commit(); + let inner_mm = LogicalMatMul::::new(&q, &k); + inner_mm.commit(); + let exp = LogicalExp::::new(&inner_mm); + exp.commit(); + let root = LogicalMatMul::::new(&exp, &v); + root.commit(); + root +} + +#[cfg(feature = "rustsat-extract")] +fn extract_backend_for_method(method: &'static str) -> ExtractBackend { + match method { + "default" => ExtractBackend::cost_model(TreeAdditiveCostModel::default()), + "eboost" => { + ExtractBackend::::eboost_heuristic(EBoostExtractConfig::default()) + } + "layered" => { + ExtractBackend::::eboost_layered(EBoostLayeredConfig::default()) + } + "rustsat" => { + ExtractBackend::::rustsat(RustsatExtractConfig::default()) + } + other => panic!("unsupported extract method `{other}`"), + } +} + +#[cfg(feature = "rustsat-extract")] +fn parse_extract_methods(methods: &[String]) -> Vec<&'static str> { + if methods.is_empty() { + return ALL_EXTRACT_METHODS.to_vec(); + } + methods + .iter() + .map(|method| match method.as_str() { + "default" => "default", + "eboost" => "eboost", + "layered" => "layered", + "rustsat" => "rustsat", + other => panic!("unsupported extract method `{other}`"), + }) + .collect() +} + +#[cfg(feature = "rustsat-extract")] +fn render_svg_for_method(target: &N, method: &'static str, svg_path: &PathBuf) -> u64 +where + N: EgglogNode + EgglogTy + 'static, +{ + NncaseVectorizeTx::extract_node_to_svg_with_backend( + target, + extract_backend_for_method(method), + svg_path, + ) + .expect("svg rendering should succeed") +} + +#[cfg(feature = "rustsat-extract")] +fn benchmark_extract_backend( + target: &N, + method: &'static str, + rewrite_peak_memory_bytes: u64, +) -> MathExtractComparisonRow +where + N: EgglogNode + EgglogTy + 'static, +{ + let extract_peak_before = current_peak_memory_bytes(); + let started = Instant::now(); + let (rendered, cost) = NncaseVectorizeTx::extract_node_to_string_with_backend( + target, + extract_backend_for_method(method), + ) + .expect("vectorize extraction should succeed"); + let svg_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("target") + .join("nncase_vectorize_extract_svgs"); + fs::create_dir_all(&svg_dir).expect("svg output directory should be creatable"); + let svg_path = svg_dir.join(format!("{method}.svg")); + let _ = render_svg_for_method(target, method, &svg_path); + let extract_peak_after = current_peak_memory_bytes(); + MathExtractComparisonRow { + method, + requested_rewrite_iters: 0, + executed_rewrite_iters: 0, + max_rewrite_mem_gib: 0, + run_ruleset_note: String::new(), + rewrite_peak_memory_bytes, + extract_peak_memory_bytes: Some(extract_peak_after.saturating_sub(extract_peak_before)), + cost: Some(cost), + elapsed: Some(started.elapsed()), + rendered, + svg_path: svg_path.display().to_string(), + timed_out: false, + } +} + +#[cfg(feature = "rustsat-extract")] +#[derive(Debug, Clone, Serialize, Deserialize)] +struct TimedExtractComparisonPayload { + rendered: String, + cost: u64, + elapsed_ms: f64, + peak_memory_bytes: u64, + svg_path: String, +} + +#[cfg(feature = "rustsat-extract")] +fn timeout_row(method: &'static str, rewrite_peak_memory_bytes: u64) -> MathExtractComparisonRow { + MathExtractComparisonRow { + method, + requested_rewrite_iters: 0, + executed_rewrite_iters: 0, + max_rewrite_mem_gib: 0, + run_ruleset_note: String::new(), + rewrite_peak_memory_bytes, + extract_peak_memory_bytes: None, + cost: None, + elapsed: None, + rendered: "NaN".to_string(), + svg_path: "n/a".to_string(), + timed_out: true, + } +} + +fn benchmark_extract_backend_with_timeout( + target: &N, + method: &'static str, + rewrite_peak_memory_bytes: u64, + max_extract_time_secs: Option, +) -> MathExtractComparisonRow +where + N: EgglogNode + EgglogTy + 'static, +{ + let payload = run_with_timeout_payload( + max_extract_time_secs, + || { + let row = benchmark_extract_backend(target, method, rewrite_peak_memory_bytes); + TimedExtractComparisonPayload { + rendered: row.rendered, + cost: row.cost.unwrap_or(0), + elapsed_ms: row.elapsed.map(duration_to_ms).unwrap_or(0.0), + peak_memory_bytes: row.extract_peak_memory_bytes.unwrap_or(0), + svg_path: row.svg_path, + } + }, + || TimedExtractComparisonPayload { + rendered: "NaN".to_string(), + cost: 0, + elapsed_ms: f64::NAN, + peak_memory_bytes: 0, + svg_path: "n/a".to_string(), + }, + ); + if payload.elapsed_ms.is_nan() { + timeout_row(method, rewrite_peak_memory_bytes) + } else { + MathExtractComparisonRow { + method, + requested_rewrite_iters: 0, + executed_rewrite_iters: 0, + max_rewrite_mem_gib: 0, + run_ruleset_note: String::new(), + rewrite_peak_memory_bytes, + extract_peak_memory_bytes: Some(payload.peak_memory_bytes), + cost: Some(payload.cost), + elapsed: Some(duration_from_ms(payload.elapsed_ms)), + rendered: payload.rendered, + svg_path: payload.svg_path, + timed_out: false, + } + } +} + +#[cfg(feature = "rustsat-extract")] +fn measure_extract_metric( + target: &N, + iteration: usize, + method: &'static str, +) -> ExtractTimelineMetric +where + N: EgglogNode + EgglogTy + 'static, +{ + let extract_peak_before = current_peak_memory_bytes(); + let started = Instant::now(); + let (_rendered, cost) = NncaseVectorizeTx::extract_node_to_string_with_backend( + target, + extract_backend_for_method(method), + ) + .expect("timeline extract should succeed"); + let elapsed_ms = elapsed_ms(started); + let svg_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("target") + .join("nncase_vectorize_timeline_svgs") + .join(format!("iter_{iteration:03}")); + fs::create_dir_all(&svg_dir).expect("timeline svg output directory should be creatable"); + let svg_path = svg_dir.join(format!("{method}.svg")); + let _ = render_svg_for_method(target, method, &svg_path); + let extract_peak_after = current_peak_memory_bytes(); + ExtractTimelineMetric { + method: method.to_string(), + cost: Some(cost), + elapsed_ms: Some(elapsed_ms), + peak_memory_bytes: Some(extract_peak_after.saturating_sub(extract_peak_before)), + svg_path: svg_path.display().to_string(), + timed_out: false, + } +} + +fn measure_extract_metric_with_timeout( + target: &N, + iteration: usize, + method: &'static str, + max_extract_time_secs: Option, +) -> ExtractTimelineMetric +where + N: EgglogNode + EgglogTy + 'static, +{ + run_with_timeout_payload( + max_extract_time_secs, + || measure_extract_metric(target, iteration, method), + || ExtractTimelineMetric { + method: method.to_string(), + cost: None, + elapsed_ms: None, + peak_memory_bytes: None, + svg_path: "n/a".to_string(), + timed_out: true, + }, + ) +} + +#[cfg(feature = "rustsat-extract")] +pub fn run_extract_comparison_with_iters_and_mem_cap( + rewrite_iters: usize, + max_rewrite_mem_gib: u64, +) -> Vec { + run_extract_comparison_with_options_and_progress( + rewrite_iters, + max_rewrite_mem_gib, + &[], + None, + |_| {}, + ) +} + +#[cfg(feature = "rustsat-extract")] +pub fn run_extract_comparison_with_options_and_progress( + rewrite_iters: usize, + max_rewrite_mem_gib: u64, + selected_extractors: &[String], + max_extract_time_secs: Option, + mut on_progress: F, +) -> Vec +where + F: FnMut(ProgressEvent), +{ + let extract_methods = parse_extract_methods(selected_extractors); + let stats = run_and_collect_stats_iters_with_mem_cap_and_progress( + rewrite_iters, + max_rewrite_mem_gib, + |event| on_progress(event), + ); + let target = build_extract_target(); + let mut rows = Vec::new(); + for (index, method) in extract_methods.iter().enumerate() { + on_progress(ProgressEvent::ExtractPhaseStart { + method, + current: index + 1, + total: extract_methods.len(), + }); + let mut row = benchmark_extract_backend_with_timeout( + &target, + method, + stats.rewrite_peak_memory_bytes, + max_extract_time_secs, + ); + row.requested_rewrite_iters = stats.requested_rewrite_iters; + row.executed_rewrite_iters = stats.executed_rewrite_iters; + row.max_rewrite_mem_gib = stats.max_rewrite_mem_gib; + row.run_ruleset_note = if stats.rewrite_stopped_early_due_to_memory_cap { + format!( + "stopped early at {} / {} iterations because peak memory exceeded {} GiB", + stats.executed_rewrite_iters, + stats.requested_rewrite_iters, + stats.max_rewrite_mem_gib + ) + } else { + "completed requested iterations".to_string() + }; + on_progress(ProgressEvent::ExtractPhaseComplete { + method, + current: index + 1, + total: extract_methods.len(), + elapsed_ms: row.elapsed.map(duration_to_ms).unwrap_or(f64::NAN), + peak_memory_bytes: row.extract_peak_memory_bytes.unwrap_or(0), + }); + rows.push(row); + } + rows +} + +#[cfg(feature = "rustsat-extract")] +pub fn run_extract_timeline_with_iters_and_mem_cap( + rewrite_iters: usize, + max_rewrite_mem_gib: u64, +) -> ExtractTimelineReport { + run_extract_timeline_with_options(rewrite_iters, max_rewrite_mem_gib, &[], None) +} + +#[cfg(feature = "rustsat-extract")] +pub fn run_extract_timeline_with_options( + rewrite_iters: usize, + max_rewrite_mem_gib: u64, + selected_extractors: &[String], + max_extract_time_secs: Option, +) -> ExtractTimelineReport { + let max_rewrite_mem_bytes = gib_to_bytes(max_rewrite_mem_gib); + let extract_methods = parse_extract_methods(selected_extractors); + NncaseVectorizeTx::reset_for_bench(); + seed_domain("nncase_vectorize_timeline_seed"); + let rs = NncaseVectorizeTx::new_ruleset("nncase_vectorize_timeline_rules"); + register_rewrite_rules(rs); + let target = build_extract_target(); + let rewrite_peak_before = current_peak_memory_bytes(); + let mut points = Vec::new(); + points.push(snapshot_timeline_point( + 0, + &RunReport::default(), + &target, + &extract_methods, + max_extract_time_secs, + rewrite_peak_before, + )); + let mut executed_rewrite_iters = 0usize; + let mut stopped_early_due_to_memory_cap = false; + for iteration in 1..rewrite_iters { + let started = Instant::now(); + let report = NncaseVectorizeTx::run_ruleset(rs, RunConfig::Once); + let rewrite_elapsed_ms = elapsed_ms(started); + executed_rewrite_iters += 1; + let current_peak = current_peak_memory_bytes(); + let tuple_count = { + let egraph = ::egraph(); + let egraph = egraph.lock().unwrap(); + egraph.num_tuples() + }; + let rule_matches = report + .num_matches_per_rule + .iter() + .map(|(name, count)| (name.to_string(), *count)) + .collect::>(); + let extracts = extract_methods + .iter() + .map(|method| { + measure_extract_metric_with_timeout( + &target, + iteration, + method, + max_extract_time_secs, + ) + }) + .collect::>(); + points.push(RewriteTimelinePoint { + iteration, + tuple_count, + rewrite_elapsed_ms, + rewrite_peak_memory_bytes: current_peak.saturating_sub(rewrite_peak_before), + rule_matches, + extracts, + }); + if current_peak > max_rewrite_mem_bytes { + stopped_early_due_to_memory_cap = true; + break; + } + } + ExtractTimelineReport { + version_nickname: None, + benchmark_family: "nncase", + benchmark_case: "vectorize", + baseline: eggplant::helpers::report::NNCASE_EGRAPH_BASELINE, + comparison_target: eggplant::helpers::report::EGGPLANT_COMPARISON_TARGET, + positioning: eggplant::helpers::report::NNCASE_EGRAPH_SLOWER_POSITIONING, + selected_extractors: extract_methods.iter().map(|m| (*m).to_string()).collect(), + max_extract_time_secs, + requested_rewrite_iters: rewrite_iters, + executed_rewrite_iters, + max_rewrite_mem_gib, + stopped_early_due_to_memory_cap, + points, + } +} + +#[cfg(feature = "rustsat-extract")] +fn snapshot_timeline_point( + iteration: usize, + report: &RunReport, + target: &N, + extract_methods: &[&'static str], + max_extract_time_secs: Option, + rewrite_peak_before: u64, +) -> RewriteTimelinePoint +where + N: EgglogNode + EgglogTy + 'static, +{ + let tuple_count = { + let egraph = ::egraph(); + let egraph = egraph.lock().unwrap(); + egraph.num_tuples() + }; + let current_peak = current_peak_memory_bytes(); + let mut rule_matches = report + .num_matches_per_rule + .iter() + .map(|(name, count)| (name.to_string(), *count)) + .collect::>(); + if rule_matches.is_empty() && iteration == 0 { + rule_matches.insert("@initial_state".to_string(), 1); + } + let extracts = extract_methods + .iter() + .map(|method| { + measure_extract_metric_with_timeout(target, iteration, method, max_extract_time_secs) + }) + .collect::>(); + RewriteTimelinePoint { + iteration, + tuple_count, + rewrite_elapsed_ms: 0.0, + rewrite_peak_memory_bytes: current_peak.saturating_sub(rewrite_peak_before), + rule_matches, + extracts, + } +} + +pub fn run_vectorize_rewrite_smoke(rewrite_iters: usize, cost_model: CM) -> String +where + CM: eggplant::egglog::extract::CostModel + 'static, +{ + NncaseVectorizeTx::reset_for_bench(); + let q = VectorizeInput::::new("q".to_owned()); + q.commit(); + let k = VectorizeInput::::new("k".to_owned()); + k.commit(); + let v = VectorizeInput::::new("v".to_owned()); + v.commit(); + let inner_mm = LogicalMatMul::::new(&q, &k); + inner_mm.commit(); + let exp = LogicalExp::::new(&inner_mm); + exp.commit(); + let root = LogicalMatMul::::new(&exp, &v); + root.commit(); + let rs = NncaseVectorizeTx::new_ruleset("nncase_vectorize_smoke_rules"); + register_rewrite_rules(rs); + for _ in 0..rewrite_iters { + NncaseVectorizeTx::run_ruleset(rs, RunConfig::Once); + } + let (rendered, _) = + NncaseVectorizeTx::extract_node_to_string_with_cost_model(&root, cost_model) + .expect("smoke extract should succeed"); + rendered +} diff --git a/src/helpers/bench_cli.rs b/src/helpers/bench_cli.rs new file mode 100644 index 0000000..f7acd72 --- /dev/null +++ b/src/helpers/bench_cli.rs @@ -0,0 +1,171 @@ +use clap::{Arg, Command, value_parser}; +use std::path::{Path, PathBuf}; + +pub const DEFAULT_EXTRACTORS: &str = "default,eboost,layered,rustsat"; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ExtractBenchCliArgs { + pub rewrite_iters: usize, + pub max_rewrite_mem_gib: u64, + pub extractors: Vec, + pub max_extract_time_secs: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct TimelineExportCliArgs { + pub rewrite_iters: usize, + pub max_rewrite_mem_gib: u64, + pub json_out: String, + pub md_out: Option, + pub plot_out: Option, + pub version_nickname: Option, + pub extractors: Vec, + pub max_extract_time_secs: Option, +} + +fn split_extractors(raw: Option<&String>) -> Vec { + raw.map(|value| { + value + .split(',') + .filter(|entry| !entry.is_empty()) + .map(ToOwned::to_owned) + .collect() + }) + .unwrap_or_default() +} + +fn leak_string(value: String) -> &'static str { + Box::leak(value.into_boxed_str()) +} + +pub fn parse_extract_bench_args( + name: &'static str, + about: &'static str, + default_rewrite_iters: usize, + default_max_rewrite_mem_gib: u64, + args: I, +) -> ExtractBenchCliArgs +where + I: IntoIterator, + T: Into + Clone, +{ + let matches = Command::new(name) + .about(about) + .arg( + Arg::new("max_iter") + .long("max_iter") + .value_parser(value_parser!(usize)) + .default_value(leak_string(default_rewrite_iters.to_string())), + ) + .arg( + Arg::new("max_mem") + .long("max_mem") + .value_parser(value_parser!(u64)) + .default_value(leak_string(default_max_rewrite_mem_gib.to_string())), + ) + .arg( + Arg::new("extractor") + .long("extractor") + .default_value(DEFAULT_EXTRACTORS), + ) + .arg( + Arg::new("max-extract-time") + .long("max-extract-time") + .value_parser(value_parser!(u64)), + ) + .get_matches_from(args); + + ExtractBenchCliArgs { + rewrite_iters: *matches.get_one::("max_iter").unwrap(), + max_rewrite_mem_gib: *matches.get_one::("max_mem").unwrap(), + extractors: split_extractors(matches.get_one::("extractor")), + max_extract_time_secs: matches.get_one::("max-extract-time").copied(), + } +} + +pub fn parse_timeline_export_args( + name: &'static str, + about: &'static str, + default_rewrite_iters: usize, + default_max_rewrite_mem_gib: u64, + default_json_out: &'static str, + args: I, +) -> TimelineExportCliArgs +where + I: IntoIterator, + T: Into + Clone, +{ + let matches = Command::new(name) + .about(about) + .arg( + Arg::new("max_iter") + .long("max_iter") + .value_parser(value_parser!(usize)) + .default_value(leak_string(default_rewrite_iters.to_string())), + ) + .arg( + Arg::new("max_mem") + .long("max_mem") + .value_parser(value_parser!(u64)) + .default_value(leak_string(default_max_rewrite_mem_gib.to_string())), + ) + .arg( + Arg::new("json-out") + .long("json-out") + .default_value(default_json_out), + ) + .arg(Arg::new("md-out").long("md-out")) + .arg(Arg::new("plot-out").long("plot-out")) + .arg(Arg::new("version-nickname").long("version-nickname")) + .arg( + Arg::new("extractor") + .long("extractor") + .default_value(DEFAULT_EXTRACTORS), + ) + .arg( + Arg::new("max-extract-time") + .long("max-extract-time") + .value_parser(value_parser!(u64)), + ) + .get_matches_from(args); + + TimelineExportCliArgs { + rewrite_iters: *matches.get_one::("max_iter").unwrap(), + max_rewrite_mem_gib: *matches.get_one::("max_mem").unwrap(), + json_out: matches.get_one::("json-out").unwrap().clone(), + md_out: matches.get_one::("md-out").cloned(), + plot_out: matches.get_one::("plot-out").cloned(), + version_nickname: matches.get_one::("version-nickname").cloned(), + extractors: split_extractors(matches.get_one::("extractor")), + max_extract_time_secs: matches.get_one::("max-extract-time").copied(), + } +} + +pub fn timeline_markdown_output_path(args: &TimelineExportCliArgs) -> PathBuf { + args.md_out + .as_ref() + .map(PathBuf::from) + .unwrap_or_else(|| PathBuf::from(&args.json_out).with_extension("md")) +} + +pub fn timeline_plot_output_path(args: &TimelineExportCliArgs) -> PathBuf { + args.plot_out + .as_ref() + .map(PathBuf::from) + .unwrap_or_else(|| PathBuf::from(&args.json_out).with_extension("png")) +} + +pub fn timeline_markdown_asset_path( + markdown_path: impl AsRef, + asset_path: impl AsRef, +) -> String { + let markdown_path = markdown_path.as_ref(); + let asset_path = asset_path.as_ref(); + let display_path = markdown_path + .parent() + .filter(|parent| !parent.as_os_str().is_empty()) + .and_then(|parent| asset_path.strip_prefix(parent).ok()) + .unwrap_or(asset_path); + + display_path.to_string_lossy().replace('\\', "/") +} diff --git a/src/helpers/mod.rs b/src/helpers/mod.rs new file mode 100644 index 0000000..f713123 --- /dev/null +++ b/src/helpers/mod.rs @@ -0,0 +1,4 @@ +pub mod bench_cli; +pub mod progress; +pub mod report; +pub mod runtime; diff --git a/src/helpers/progress.rs b/src/helpers/progress.rs new file mode 100644 index 0000000..a2280eb --- /dev/null +++ b/src/helpers/progress.rs @@ -0,0 +1,161 @@ +use indicatif::{MultiProgress, ProgressBar, ProgressStyle}; +use std::time::Duration; + +pub struct BenchProgress { + rewrite_bar: ProgressBar, + extract_bar: ProgressBar, +} + +pub struct TimelineExtractMetric<'a> { + pub method: &'a str, + pub elapsed_ms: Option, + pub peak_memory_bytes: Option, +} + +impl BenchProgress { + pub fn new(rewrite_len: u64, extract_len: u64) -> Self { + let mp = MultiProgress::new(); + let rewrite_bar = make_bar(&mp, rewrite_len, "rewrite"); + let extract_bar = make_bar(&mp, extract_len, "extract"); + Self { + rewrite_bar, + extract_bar, + } + } + + pub fn rewrite_iteration_complete( + &self, + current: usize, + total: usize, + tuple_count: usize, + peak_memory_bytes: u64, + ) { + self.rewrite_bar.set_length(total as u64); + self.rewrite_bar.set_position(current as u64); + self.rewrite_bar.set_message(format!( + "tuples={} peak={}", + tuple_count, + format_bytes(peak_memory_bytes) + )); + } + + pub fn rewrite_stopped( + &self, + current: usize, + total: usize, + peak_memory_bytes: u64, + cap_bytes: u64, + ) { + self.rewrite_bar.set_length(total as u64); + self.rewrite_bar.set_position(current as u64); + self.rewrite_bar.finish_with_message(format!( + "stopped: peak={} cap={}", + format_bytes(peak_memory_bytes), + format_bytes(cap_bytes) + )); + } + + pub fn extract_phase_start(&self, method: &str, current: usize, total: usize) { + self.extract_bar.set_length(total as u64); + self.extract_bar + .set_position((current.saturating_sub(1)) as u64); + self.extract_bar.set_message(format!("starting {method}")); + } + + pub fn extract_phase_complete( + &self, + method: &str, + current: usize, + total: usize, + elapsed_ms: f64, + peak_memory_bytes: u64, + ) { + self.extract_bar.set_length(total as u64); + self.extract_bar.set_position(current as u64); + self.extract_bar.set_message(format!( + "{} done in {}, peak={}", + method, + if elapsed_ms.is_nan() { + "NaN".to_string() + } else { + format!("{elapsed_ms:.3} ms") + }, + if peak_memory_bytes == 0 { + "NaN".to_string() + } else { + format_bytes(peak_memory_bytes) + } + )); + } + + pub fn timeline_iteration( + &self, + rewrite_position: u64, + iteration_label: usize, + tuple_count: usize, + rewrite_peak_memory_bytes: u64, + extract_metrics: &[TimelineExtractMetric<'_>], + ) { + self.rewrite_bar.set_position(rewrite_position); + self.rewrite_bar.set_message(format!( + "iter={} tuples={} peak={}", + iteration_label, + tuple_count, + format_bytes(rewrite_peak_memory_bytes) + )); + for (idx, metric) in extract_metrics.iter().enumerate() { + self.extract_bar.set_position((idx + 1) as u64); + self.extract_bar.set_message(format!( + "iter {} {} {} peak={}", + iteration_label, + metric.method, + format_optional_ms(metric.elapsed_ms), + format_optional_bytes(metric.peak_memory_bytes) + )); + } + } + + pub fn finish(&self) { + if !self.rewrite_bar.is_finished() { + self.rewrite_bar.finish_with_message("completed"); + } + if !self.extract_bar.is_finished() { + self.extract_bar.finish_with_message("completed"); + } + } +} + +pub fn format_duration(duration: Duration) -> String { + format!("{:.3} ms", duration.as_secs_f64() * 1000.0) +} + +pub fn format_optional_duration(duration: Option) -> String { + duration + .map(format_duration) + .unwrap_or_else(|| "NaN".to_string()) +} + +pub fn format_bytes(bytes: u64) -> String { + format!("{:.2} MiB", bytes as f64 / (1024.0 * 1024.0)) +} + +pub fn format_optional_bytes(bytes: Option) -> String { + bytes.map(format_bytes).unwrap_or_else(|| "NaN".to_string()) +} + +pub fn format_optional_ms(value: Option) -> String { + value + .map(|ms| format!("{ms:.3} ms")) + .unwrap_or_else(|| "NaN ms".to_string()) +} + +fn make_bar(mp: &MultiProgress, len: u64, prefix: &str) -> ProgressBar { + let bar = mp.add(ProgressBar::new(len)); + bar.set_prefix(prefix.to_string()); + bar.set_style( + ProgressStyle::with_template("{prefix:>14} [{bar:40.cyan/blue}] {pos:>3}/{len:<3} {msg}") + .unwrap() + .progress_chars("=> "), + ); + bar +} diff --git a/src/helpers/report.rs b/src/helpers/report.rs new file mode 100644 index 0000000..44522a2 --- /dev/null +++ b/src/helpers/report.rs @@ -0,0 +1,867 @@ +use crate::helpers::bench_cli::ExtractBenchCliArgs; +use crate::helpers::progress::{format_bytes, format_optional_bytes, format_optional_duration}; +use serde::Serialize; +use serde_json::Value as JsonValue; +use std::collections::BTreeMap; +use std::path::Path; +use std::time::Duration; + +#[derive(Debug, Clone)] +pub struct ExtractReportRow { + pub method: String, + pub requested_rewrite_iters: usize, + pub executed_rewrite_iters: usize, + pub max_rewrite_mem_gib: u64, + pub run_ruleset_note: String, + pub rewrite_peak_memory_bytes: u64, + pub extract_peak_memory_bytes: Option, + pub elapsed: Option, + pub rendered: String, + pub svg_path: String, +} + +pub struct BenchmarkPositioning<'a> { + pub benchmark_family: &'a str, + pub benchmark_case: &'a str, + pub baseline: &'a str, + pub comparison_target: &'a str, + pub positioning: &'a str, +} + +pub struct BenchmarkWorkloadSpec<'a> { + pub positioning: BenchmarkPositioning<'a>, + pub op_costs: &'a [(&'a str, u64)], + pub target_root: &'a str, + pub rewrite_rules: &'a [&'a str], + pub rule_witnesses: &'a [(&'a str, &'a str)], +} + +pub const NNCASE_EGRAPH_BASELINE: &str = "nncase egraph implementation"; +pub const EGGPLANT_COMPARISON_TARGET: &str = "eggplant"; +pub const NNCASE_EGRAPH_SLOWER_POSITIONING: &str = "This nncase workload is included because the original nncase egraph implementation is slower than eggplant on this rewrite/extract shape."; + +pub fn nncase_benchmark_positioning(benchmark_case: &str) -> BenchmarkPositioning<'_> { + BenchmarkPositioning { + benchmark_family: "nncase", + benchmark_case, + baseline: NNCASE_EGRAPH_BASELINE, + comparison_target: EGGPLANT_COMPARISON_TARGET, + positioning: NNCASE_EGRAPH_SLOWER_POSITIONING, + } +} + +pub fn print_benchmark_positioning(positioning: &BenchmarkPositioning<'_>) { + println!("Benchmark positioning:"); + println!(" Family: {}", positioning.benchmark_family); + println!(" Case: {}", positioning.benchmark_case); + println!(" Baseline: {}", positioning.baseline); + println!(" Comparison target: {}", positioning.comparison_target); + println!(" Note: {}", positioning.positioning); + println!(); +} + +pub fn print_benchmark_workload_spec(spec: &BenchmarkWorkloadSpec<'_>) { + print_benchmark_positioning(&spec.positioning); + println!("Nncase workload:"); + println!(" Target root: {}", spec.target_root); + println!(" Op costs:"); + for (op, cost) in spec.op_costs { + println!(" {op}: {cost}"); + } + println!(" Rewrite rules:"); + for rule in spec.rewrite_rules { + println!(" {rule}"); + } + println!(" Rule witnesses:"); + for (rule, witness) in spec.rule_witnesses { + println!(" {rule}: {witness}"); + } + println!(); +} + +pub fn print_extract_run_configuration(args: &ExtractBenchCliArgs) { + println!("Requested rewrite iterations: {}", args.rewrite_iters); + println!("Run ruleset memory cap: {} GiB", args.max_rewrite_mem_gib); + println!("Selected extractors: {}", args.extractors.join(", ")); + println!( + "Max extract time: {}", + args.max_extract_time_secs + .map(|secs| format!("{secs} s")) + .unwrap_or_else(|| "unlimited".to_string()) + ); + println!(); +} + +pub fn print_extract_comparison_report(title: &str, rows: I) +where + I: IntoIterator, +{ + println!("{title}"); + println!( + "| Extract Method | Requested Iters | Executed Iters | Max Rewrite Mem | Run Ruleset Note | Run Ruleset Peak Mem | Extract Peak Mem | Time | Best Expression | SVG Path |" + ); + println!("| --- | ---: | ---: | ---: | --- | ---: | ---: | ---: | --- | --- |"); + for row in rows { + println!( + "| {} | {} | {} | {} GiB | {} | {} | {} | {} | `{}` | `{}` |", + row.method, + row.requested_rewrite_iters, + row.executed_rewrite_iters, + row.max_rewrite_mem_gib, + row.run_ruleset_note.replace('|', "\\|"), + format_bytes(row.rewrite_peak_memory_bytes), + format_optional_bytes(row.extract_peak_memory_bytes), + format_optional_duration(row.elapsed), + row.rendered.replace('|', "\\|"), + row.svg_path.replace('|', "\\|") + ); + } +} + +pub fn render_timeline_markdown_report(title: &str, report: &T) -> serde_json::Result +where + T: Serialize, +{ + render_timeline_markdown_report_with_plot(title, report, None) +} + +pub fn render_timeline_markdown_report_with_plot( + title: &str, + report: &T, + plot_path: Option<&str>, +) -> serde_json::Result +where + T: Serialize, +{ + let value = serde_json::to_value(report)?; + Ok(render_timeline_markdown_value(title, &value, plot_path)) +} + +pub fn write_timeline_markdown_report( + title: &str, + report: &T, + output_path: impl AsRef, +) -> std::io::Result<()> +where + T: Serialize, +{ + let markdown = render_timeline_markdown_report(title, report) + .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?; + write_markdown(output_path, markdown) +} + +pub fn write_timeline_markdown_report_with_plot( + title: &str, + report: &T, + output_path: impl AsRef, + plot_path: Option<&str>, +) -> std::io::Result<()> +where + T: Serialize, +{ + let markdown = render_timeline_markdown_report_with_plot(title, report, plot_path) + .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?; + write_markdown(output_path, markdown) +} + +fn write_markdown(output_path: impl AsRef, markdown: String) -> std::io::Result<()> { + let output_path = output_path.as_ref(); + if let Some(parent) = output_path + .parent() + .filter(|parent| !parent.as_os_str().is_empty()) + { + std::fs::create_dir_all(parent)?; + } + std::fs::write(output_path, markdown) +} + +#[cfg(feature = "timeline-plot")] +#[derive(Debug, Clone)] +struct TimelinePlotMetric { + elapsed_ms: Option, + peak_mib: Option, + cost: Option, +} + +#[cfg(feature = "timeline-plot")] +#[derive(Debug, Clone)] +struct TimelinePlotPoint { + iteration: f64, + tuple_count: Option, + rewrite_elapsed_ms: Option, + rewrite_peak_mib: Option, + extracts: BTreeMap, +} + +#[cfg(feature = "timeline-plot")] +#[derive(Debug, Clone)] +struct TimelinePlotSeries { + label: Option, + points: Vec<(f64, f64)>, +} + +#[cfg(feature = "timeline-plot")] +pub fn write_timeline_plot_png( + title: &str, + report: &T, + output_path: impl AsRef, +) -> std::io::Result<()> +where + T: Serialize, +{ + let value = serde_json::to_value(report) + .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?; + write_timeline_plot_png_value(title, &value, output_path.as_ref()) +} + +#[cfg(feature = "timeline-plot")] +fn write_timeline_plot_png_value( + base_title: &str, + report: &JsonValue, + output_path: &Path, +) -> std::io::Result<()> { + use plotters::coord::Shift; + use plotters::prelude::*; + + fn plot_err(err: DrawingAreaErrorKind) -> std::io::Error + where + E: std::error::Error + Send + Sync + std::fmt::Debug + 'static, + { + std::io::Error::new(std::io::ErrorKind::Other, format!("{err:?}")) + } + + fn draw_line_panel( + area: &DrawingArea, Shift>, + title: &str, + y_label: &str, + x_range: std::ops::Range, + series: &[TimelinePlotSeries], + show_legend: bool, + ) -> std::io::Result<()> { + let mut chart = ChartBuilder::on(area) + .caption(title, ("sans-serif", 28)) + .margin(18) + .x_label_area_size(46) + .y_label_area_size(82) + .build_cartesian_2d(x_range, plot_y_range(series)) + .map_err(plot_err)?; + + chart + .configure_mesh() + .x_desc("Iteration") + .y_desc(y_label) + .label_style(("sans-serif", 18)) + .axis_desc_style(("sans-serif", 20)) + .draw() + .map_err(plot_err)?; + + for (idx, line) in series.iter().enumerate() { + if line.points.is_empty() { + continue; + } + let color = Palette99::pick(idx).mix(0.95); + let line_style = ShapeStyle::from(&color).stroke_width(3); + let points = line.points.clone(); + let drawn = chart + .draw_series(LineSeries::new(points.clone(), line_style)) + .map_err(plot_err)?; + if let Some(label) = &line.label { + let legend_style = line_style; + drawn.label(label.clone()).legend(move |(x, y)| { + PathElement::new(vec![(x, y), (x + 25, y)], legend_style) + }); + } + chart + .draw_series( + points + .iter() + .map(|(x, y)| Circle::new((*x, *y), 5, color.filled())), + ) + .map_err(plot_err)?; + } + + if show_legend { + chart + .configure_series_labels() + .background_style(WHITE.mix(0.85)) + .border_style(BLACK) + .label_font(("sans-serif", 18)) + .draw() + .map_err(plot_err)?; + } + + Ok(()) + } + + if let Some(parent) = output_path + .parent() + .filter(|parent| !parent.as_os_str().is_empty()) + { + std::fs::create_dir_all(parent)?; + } + + let points = collect_timeline_plot_points(report); + let methods = selected_timeline_plot_methods(report, &points); + let x_range = plot_x_range(&points); + let root = BitMapBackend::new(output_path, (2560, 2240)).into_drawing_area(); + root.fill(&WHITE).map_err(plot_err)?; + let body = root + .titled( + &timeline_report_title(base_title, report), + ("sans-serif", 44), + ) + .map_err(plot_err)?; + let areas = body.split_evenly((3, 2)); + + draw_line_panel( + &areas[0], + "Tuple Count by Iteration", + "Tuples", + x_range.clone(), + &[TimelinePlotSeries { + label: None, + points: points + .iter() + .filter_map(|point| point.tuple_count.map(|value| (point.iteration, value))) + .collect(), + }], + false, + )?; + draw_line_panel( + &areas[1], + "Rewrite Time by Iteration", + "ms", + x_range.clone(), + &[TimelinePlotSeries { + label: Some("rewrite elapsed".to_string()), + points: points + .iter() + .filter_map(|point| { + point + .rewrite_elapsed_ms + .map(|value| (point.iteration, value)) + }) + .collect(), + }], + true, + )?; + draw_line_panel( + &areas[2], + "Rewrite Peak Memory by Iteration", + "MiB", + x_range.clone(), + &[TimelinePlotSeries { + label: None, + points: points + .iter() + .filter_map(|point| point.rewrite_peak_mib.map(|value| (point.iteration, value))) + .collect(), + }], + false, + )?; + draw_line_panel( + &areas[3], + "Extraction Time by Iteration", + "ms", + x_range.clone(), + &method_series(&points, &methods, |metric| metric.elapsed_ms), + true, + )?; + draw_line_panel( + &areas[4], + "Extraction Peak Memory by Iteration", + "MiB", + x_range.clone(), + &method_series(&points, &methods, |metric| metric.peak_mib), + true, + )?; + draw_line_panel( + &areas[5], + "Extraction Cost by Iteration", + "Cost", + x_range, + &method_series(&points, &methods, |metric| metric.cost), + true, + )?; + + root.present().map_err(plot_err) +} + +#[cfg(feature = "timeline-plot")] +fn collect_timeline_plot_points(report: &JsonValue) -> Vec { + report + .get("points") + .and_then(JsonValue::as_array) + .into_iter() + .flatten() + .map(|point| { + let extracts = point + .get("extracts") + .and_then(JsonValue::as_array) + .into_iter() + .flatten() + .filter_map(|metric| { + let method = metric.get("method")?.as_str()?.to_string(); + Some(( + method, + TimelinePlotMetric { + elapsed_ms: metric.get("elapsed_ms").and_then(JsonValue::as_f64), + peak_mib: metric + .get("peak_memory_bytes") + .and_then(JsonValue::as_u64) + .map(bytes_to_mib), + cost: metric.get("cost").and_then(JsonValue::as_f64), + }, + )) + }) + .collect(); + + TimelinePlotPoint { + iteration: point + .get("iteration") + .and_then(JsonValue::as_f64) + .unwrap_or(0.0), + tuple_count: point.get("tuple_count").and_then(JsonValue::as_f64), + rewrite_elapsed_ms: point.get("rewrite_elapsed_ms").and_then(JsonValue::as_f64), + rewrite_peak_mib: point + .get("rewrite_peak_memory_bytes") + .and_then(JsonValue::as_u64) + .map(bytes_to_mib), + extracts, + } + }) + .collect() +} + +#[cfg(feature = "timeline-plot")] +fn selected_timeline_plot_methods(report: &JsonValue, points: &[TimelinePlotPoint]) -> Vec { + let selected = report + .get("selected_extractors") + .and_then(JsonValue::as_array) + .into_iter() + .flatten() + .filter_map(JsonValue::as_str) + .map(ToOwned::to_owned) + .collect::>(); + if !selected.is_empty() { + return selected; + } + + points + .first() + .map(|point| point.extracts.keys().cloned().collect()) + .unwrap_or_default() +} + +#[cfg(feature = "timeline-plot")] +fn method_series( + points: &[TimelinePlotPoint], + methods: &[String], + value: impl Fn(&TimelinePlotMetric) -> Option, +) -> Vec { + methods + .iter() + .map(|method| TimelinePlotSeries { + label: Some(method.clone()), + points: points + .iter() + .filter_map(|point| { + point + .extracts + .get(method) + .and_then(|metric| value(metric)) + .map(|value| (point.iteration, value)) + }) + .collect(), + }) + .collect() +} + +#[cfg(feature = "timeline-plot")] +fn plot_x_range(points: &[TimelinePlotPoint]) -> std::ops::Range { + let min = points + .iter() + .map(|point| point.iteration) + .fold(f64::INFINITY, f64::min); + let max = points + .iter() + .map(|point| point.iteration) + .fold(f64::NEG_INFINITY, f64::max); + if !min.is_finite() || !max.is_finite() { + return 0.0..1.0; + } + if (max - min).abs() < f64::EPSILON { + return (min - 1.0)..(max + 1.0); + } + min..max +} + +#[cfg(feature = "timeline-plot")] +fn plot_y_range(series: &[TimelinePlotSeries]) -> std::ops::Range { + let mut min = f64::INFINITY; + let mut max = f64::NEG_INFINITY; + for value in series + .iter() + .flat_map(|line| line.points.iter().map(|(_, y)| *y)) + .filter(|value| value.is_finite()) + { + min = min.min(value); + max = max.max(value); + } + + if !min.is_finite() || !max.is_finite() { + return 0.0..1.0; + } + + if min >= 0.0 { + min = 0.0; + } + if (max - min).abs() < f64::EPSILON { + let pad = if max.abs() < 1.0 { + 1.0 + } else { + max.abs() * 0.1 + }; + return min..(max + pad); + } + + let pad = (max - min) * 0.1; + let start = if min >= 0.0 { 0.0 } else { min - pad }; + start..(max + pad) +} + +#[cfg(feature = "timeline-plot")] +fn bytes_to_mib(bytes: u64) -> f64 { + bytes as f64 / (1024.0 * 1024.0) +} + +fn render_timeline_markdown_value( + base_title: &str, + report: &JsonValue, + plot_path: Option<&str>, +) -> String { + let points = report + .get("points") + .and_then(JsonValue::as_array) + .map(Vec::as_slice) + .unwrap_or(&[]); + let selected_extractors = report + .get("selected_extractors") + .and_then(JsonValue::as_array) + .map(|values| { + values + .iter() + .filter_map(JsonValue::as_str) + .collect::>() + .join(", ") + }) + .filter(|value| !value.is_empty()) + .unwrap_or_else(|| "n/a".to_string()); + let title = timeline_report_title(base_title, report); + let mut rule_totals = BTreeMap::::new(); + for point in points { + if let Some(rule_matches) = point.get("rule_matches").and_then(JsonValue::as_object) { + for (rule, count) in rule_matches { + *rule_totals.entry(rule.clone()).or_default() += count.as_u64().unwrap_or(0); + } + } + } + + let mut lines = vec![ + format!("# {title}"), + String::new(), + "## Report Metadata".to_string(), + String::new(), + "| Key | Value |".to_string(), + "| --- | --- |".to_string(), + format!( + "| Version Nickname | {} |", + markdown_cell( + report + .get("version_nickname") + .and_then(JsonValue::as_str) + .unwrap_or("n/a") + ) + ), + format!( + "| Selected Extractors | {} |", + markdown_cell(&selected_extractors) + ), + format!( + "| Max Extract Time | {} |", + report + .get("max_extract_time_secs") + .and_then(JsonValue::as_u64) + .map(|secs| format!("{secs} s")) + .unwrap_or_else(|| "n/a".to_string()) + ), + format!( + "| Requested Iters | {} |", + json_u64_cell(report, "requested_rewrite_iters") + ), + format!( + "| Executed Iters | {} |", + json_u64_cell(report, "executed_rewrite_iters") + ), + format!( + "| Max Rewrite Mem | {} GiB |", + json_u64_cell(report, "max_rewrite_mem_gib") + ), + format!( + "| Stopped Early | {} |", + report + .get("stopped_early_due_to_memory_cap") + .and_then(JsonValue::as_bool) + .map(|value| value.to_string()) + .unwrap_or_else(|| "n/a".to_string()) + ), + String::new(), + ]; + + if has_benchmark_positioning(report) { + lines.extend([ + "## Benchmark Positioning".to_string(), + String::new(), + "| Key | Value |".to_string(), + "| --- | --- |".to_string(), + format!( + "| Benchmark Family | {} |", + json_str_markdown_cell(report, "benchmark_family") + ), + format!( + "| Benchmark Case | {} |", + json_str_markdown_cell(report, "benchmark_case") + ), + format!( + "| Baseline | {} |", + json_str_markdown_cell(report, "baseline") + ), + format!( + "| Comparison Target | {} |", + json_str_markdown_cell(report, "comparison_target") + ), + format!( + "| Positioning | {} |", + json_str_markdown_cell(report, "positioning") + ), + String::new(), + ]); + } + + if let Some(plot_path) = plot_path.filter(|path| !path.is_empty()) { + lines.extend([ + "## Timeline Plot".to_string(), + String::new(), + format!("![Timeline Plot]({plot_path})"), + String::new(), + ]); + } + + lines.extend(["## Rule Match Totals".to_string(), String::new()]); + + if rule_totals.is_empty() { + lines.push("No rule matches recorded.".to_string()); + } else { + lines.push("| Rule | Total Matches |".to_string()); + lines.push("| --- | ---: |".to_string()); + for (rule, count) in &rule_totals { + lines.push(format!("| {} | {count} |", markdown_cell(rule))); + } + } + + lines.extend([ + String::new(), + "## Rule Matches Per Iteration".to_string(), + String::new(), + ]); + if rule_totals.is_empty() { + lines.push("No rule matches recorded.".to_string()); + } else { + let rule_names = rule_totals.keys().cloned().collect::>(); + lines.push(format!( + "| Iteration | {} |", + rule_names + .iter() + .map(|rule| markdown_cell(rule)) + .collect::>() + .join(" | ") + )); + lines.push(format!( + "| ---: | {} |", + rule_names + .iter() + .map(|_| "---:") + .collect::>() + .join(" | ") + )); + for point in points { + let rule_matches = point.get("rule_matches").and_then(JsonValue::as_object); + let cells = rule_names + .iter() + .map(|rule| { + rule_matches + .and_then(|matches| matches.get(rule)) + .and_then(JsonValue::as_u64) + .unwrap_or(0) + .to_string() + }) + .collect::>() + .join(" | "); + lines.push(format!( + "| {} | {cells} |", + value_u64_cell(point.get("iteration")) + )); + } + } + + lines.extend([ + String::new(), + "## Per-Iteration Metrics".to_string(), + String::new(), + "| Iteration | Tuples | Rewrite ms | Rewrite MiB |".to_string(), + "| ---: | ---: | ---: | ---: |".to_string(), + ]); + for point in points { + lines.push(format!( + "| {} | {} | {} | {} |", + value_u64_cell(point.get("iteration")), + value_u64_cell(point.get("tuple_count")), + value_f64_cell(point.get("rewrite_elapsed_ms"), 3), + value_mib_cell(point.get("rewrite_peak_memory_bytes")) + )); + } + + lines.extend([ + String::new(), + "## Per-Iteration SVGs".to_string(), + String::new(), + "| Iteration | Method | Tuples | Rewrite ms | Rewrite MiB | Extract ms | Cost | Extract MiB | Timed Out | SVG Path | Preview |".to_string(), + "| ---: | --- | ---: | ---: | ---: | ---: | ---: | ---: | --- | --- | --- |".to_string(), + ]); + for point in points { + let extracts = point + .get("extracts") + .and_then(JsonValue::as_array) + .map(Vec::as_slice) + .unwrap_or(&[]); + for metric in extracts { + let method = metric + .get("method") + .and_then(JsonValue::as_str) + .unwrap_or("n/a"); + let svg_path = metric + .get("svg_path") + .and_then(JsonValue::as_str) + .unwrap_or("n/a"); + let (svg_cell, preview_cell) = if svg_path == "n/a" || svg_path.is_empty() { + ("n/a".to_string(), "n/a".to_string()) + } else { + ( + format!("[{}]({})", markdown_cell(svg_path), svg_path), + format!( + "![{} iteration {}]({})", + markdown_cell(method), + value_u64_cell(point.get("iteration")), + svg_path + ), + ) + }; + lines.push(format!( + "| {} | {} | {} | {} | {} | {} | {} | {} | {} | {} | {} |", + value_u64_cell(point.get("iteration")), + markdown_cell(method), + value_u64_cell(point.get("tuple_count")), + value_f64_cell(point.get("rewrite_elapsed_ms"), 3), + value_mib_cell(point.get("rewrite_peak_memory_bytes")), + metric + .get("elapsed_ms") + .and_then(JsonValue::as_f64) + .map(|value| format!("{value:.3} ms")) + .unwrap_or_else(|| "NaN".to_string()), + value_number_cell(metric.get("cost")), + value_mib_cell(metric.get("peak_memory_bytes")), + metric + .get("timed_out") + .and_then(JsonValue::as_bool) + .map(|value| value.to_string()) + .unwrap_or_else(|| "n/a".to_string()), + svg_cell, + preview_cell + )); + } + } + + lines.push(String::new()); + lines.join("\n") +} + +fn json_u64_cell(value: &JsonValue, key: &str) -> String { + value_u64_cell(value.get(key)) +} + +fn json_str_markdown_cell(value: &JsonValue, key: &str) -> String { + value + .get(key) + .and_then(JsonValue::as_str) + .filter(|value| !value.is_empty()) + .map(markdown_cell) + .unwrap_or_else(|| "n/a".to_string()) +} + +fn has_benchmark_positioning(report: &JsonValue) -> bool { + [ + "benchmark_family", + "benchmark_case", + "baseline", + "comparison_target", + "positioning", + ] + .iter() + .any(|key| { + report + .get(key) + .and_then(JsonValue::as_str) + .is_some_and(|value| !value.is_empty()) + }) +} + +fn timeline_report_title(base_title: &str, report: &JsonValue) -> String { + report + .get("version_nickname") + .and_then(JsonValue::as_str) + .filter(|value| !value.is_empty()) + .map(|nickname| format!("{base_title} - {nickname}")) + .unwrap_or_else(|| base_title.to_string()) +} + +fn value_u64_cell(value: Option<&JsonValue>) -> String { + value + .and_then(JsonValue::as_u64) + .map(|value| value.to_string()) + .unwrap_or_else(|| "n/a".to_string()) +} + +fn value_f64_cell(value: Option<&JsonValue>, precision: usize) -> String { + value + .and_then(JsonValue::as_f64) + .map(|value| format!("{value:.precision$}")) + .unwrap_or_else(|| "NaN".to_string()) +} + +fn value_mib_cell(value: Option<&JsonValue>) -> String { + value + .and_then(JsonValue::as_u64) + .map(|bytes| format!("{:.2}", bytes as f64 / (1024.0 * 1024.0))) + .unwrap_or_else(|| "NaN".to_string()) +} + +fn value_number_cell(value: Option<&JsonValue>) -> String { + value + .and_then(JsonValue::as_number) + .map(ToString::to_string) + .unwrap_or_else(|| "NaN".to_string()) +} + +fn markdown_cell(value: &str) -> String { + value.replace('|', "\\|").replace('\n', "
") +} diff --git a/src/helpers/runtime.rs b/src/helpers/runtime.rs new file mode 100644 index 0000000..acdd870 --- /dev/null +++ b/src/helpers/runtime.rs @@ -0,0 +1,114 @@ +use std::time::{Duration, Instant}; + +pub fn gib_to_bytes(gib: u64) -> u64 { + gib.saturating_mul(1024) + .saturating_mul(1024) + .saturating_mul(1024) +} + +pub fn elapsed_ms(started: Instant) -> f64 { + started.elapsed().as_secs_f64() * 1000.0 +} + +pub fn duration_to_ms(duration: Duration) -> f64 { + duration.as_secs_f64() * 1000.0 +} + +pub fn duration_from_ms(ms: f64) -> Duration { + Duration::from_secs_f64(ms / 1000.0) +} + +pub fn current_peak_memory_bytes() -> u64 { + let mut usage = std::mem::MaybeUninit::::uninit(); + let rc = unsafe { libc::getrusage(libc::RUSAGE_SELF, usage.as_mut_ptr()) }; + if rc != 0 { + return 0; + } + let usage = unsafe { usage.assume_init() }; + #[cfg(target_os = "macos")] + { + usage.ru_maxrss as u64 + } + #[cfg(not(target_os = "macos"))] + { + (usage.ru_maxrss as u64) * 1024 + } +} + +#[cfg(unix)] +pub fn run_with_timeout_payload(timeout_secs: Option, work: F, on_timeout: T) -> P +where + P: serde::Serialize + serde::de::DeserializeOwned, + F: FnOnce() -> P, + T: Fn() -> P, +{ + let Some(timeout_secs) = timeout_secs else { + return work(); + }; + + let mut fds = [0; 2]; + if unsafe { libc::pipe(fds.as_mut_ptr()) } != 0 { + return work(); + } + + let pid = unsafe { libc::fork() }; + if pid == 0 { + unsafe { + libc::close(fds[0]); + } + let payload = work(); + let bytes = serde_json::to_vec(&payload).unwrap_or_default(); + unsafe { + libc::write(fds[1], bytes.as_ptr().cast(), bytes.len()); + libc::close(fds[1]); + libc::_exit(0); + } + } + + unsafe { + libc::close(fds[1]); + } + + let started = Instant::now(); + let mut status = 0; + loop { + let wait_result = unsafe { libc::waitpid(pid, &mut status, libc::WNOHANG) }; + if wait_result == pid { + let mut payload = Vec::new(); + let mut buffer = [0u8; 4096]; + loop { + let read_bytes = + unsafe { libc::read(fds[0], buffer.as_mut_ptr().cast(), buffer.len()) }; + if read_bytes <= 0 { + break; + } + payload.extend_from_slice(&buffer[..read_bytes as usize]); + } + unsafe { + libc::close(fds[0]); + } + return serde_json::from_slice(&payload).unwrap_or_else(|_| on_timeout()); + } + + if started.elapsed() >= Duration::from_secs(timeout_secs) { + unsafe { + libc::kill(pid, libc::SIGKILL); + libc::waitpid(pid, &mut status, 0); + libc::close(fds[0]); + } + return on_timeout(); + } + + std::thread::sleep(Duration::from_millis(10)); + } +} + +#[cfg(not(unix))] +pub fn run_with_timeout_payload(_timeout_secs: Option, work: F, _on_timeout: T) -> P +where + P: serde::Serialize + serde::de::DeserializeOwned, + F: FnOnce() -> P, + T: Fn() -> P, +{ + work() +} diff --git a/tests/math_microbench_compare.rs b/tests/math_microbench_compare.rs index 7a8ae73..cb2372a 100644 --- a/tests/math_microbench_compare.rs +++ b/tests/math_microbench_compare.rs @@ -1,7 +1,7 @@ -#[path = "../benches/runners/eggplant_rewrite/math_microbenchmark.rs"] -mod typed_math_microbenchmark; #[path = "../examples/math_microbenchmark_support.rs"] mod rust_rule_math_microbenchmark; +#[path = "../benches/runners/eggplant_rewrite/math_microbenchmark.rs"] +mod typed_math_microbenchmark; #[test] fn typed_math_microbenchmark_stats_are_non_empty() { diff --git a/tests/math_microbench_div_distrib.rs b/tests/math_microbench_div_distrib.rs new file mode 100644 index 0000000..85b14a5 --- /dev/null +++ b/tests/math_microbench_div_distrib.rs @@ -0,0 +1,44 @@ +#[path = "../benches/runners/eggplant_rewrite/math_microbenchmark.rs"] +mod typed_math_microbenchmark; + +#[derive(Default, Clone)] +struct PreferDistributedDivisionCost; + +impl eggplant::egglog::extract::CostModel + for PreferDistributedDivisionCost +{ + fn fold( + &self, + _head: &str, + children_cost: &[eggplant::egglog::extract::DefaultCost], + head_cost: eggplant::egglog::extract::DefaultCost, + ) -> eggplant::egglog::extract::DefaultCost { + children_cost + .iter() + .fold(head_cost, |sum, child| sum.saturating_add(*child)) + } + + fn enode_cost( + &self, + _egraph: &eggplant::egglog::EGraph, + func: &eggplant::egglog::Function, + row: &eggplant::egglog::FunctionRow, + ) -> eggplant::egglog::extract::DefaultCost { + match func.name() { + "MDiv" if row.vals.len() >= 2 => 100, + "MAdd" => 0, + _ => 1, + } + } +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn math_microbenchmark_rewrites_distribute_division_over_addition() { + let rendered = + typed_math_microbenchmark::run_div_add_rewrite_smoke(1, PreferDistributedDivisionCost); + assert!( + rendered.contains("MAdd") && rendered.matches("MDiv").count() >= 2, + "expected division-over-addition rewrite to expose two MDiv terms, got: {rendered}" + ); +} diff --git a/tests/math_microbench_extract_cli.rs b/tests/math_microbench_extract_cli.rs new file mode 100644 index 0000000..d4f9665 --- /dev/null +++ b/tests/math_microbench_extract_cli.rs @@ -0,0 +1,53 @@ +#[cfg(feature = "rustsat-extract")] +#[path = "../examples/math_microbenchmark_no_calculus_extract_bench.rs"] +mod math_microbenchmark_extract_bench; + +#[cfg(feature = "rustsat-extract")] +#[test] +fn parse_cli_iters_defaults_to_eleven() { + let parsed = math_microbenchmark_extract_bench::parse_args(["extract-bench"]); + assert_eq!(parsed.rewrite_iters, 11); + assert_eq!(parsed.max_rewrite_mem_gib, 20); +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn parse_cli_iters_accepts_explicit_flag() { + let parsed = + math_microbenchmark_extract_bench::parse_args(["extract-bench", "--max_iter", "3"]); + assert_eq!(parsed.rewrite_iters, 3); + assert_eq!(parsed.max_rewrite_mem_gib, 20); +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn parse_cli_accepts_memory_cap_flag() { + let parsed = + math_microbenchmark_extract_bench::parse_args(["extract-bench", "--max_mem", "12"]); + assert_eq!(parsed.rewrite_iters, 11); + assert_eq!(parsed.max_rewrite_mem_gib, 12); +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn parse_cli_accepts_long_clap_style_equals_syntax() { + let parsed = math_microbenchmark_extract_bench::parse_args([ + "extract-bench", + "--max_iter=7", + "--max_mem=9", + ]); + assert_eq!(parsed.rewrite_iters, 7); + assert_eq!(parsed.max_rewrite_mem_gib, 9); +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn parse_cli_accepts_extractor_filter_and_timeout() { + let parsed = math_microbenchmark_extract_bench::parse_args([ + "extract-bench", + "--extractor=default,layered", + "--max-extract-time=3", + ]); + assert_eq!(parsed.extractors, vec!["default", "layered"]); + assert_eq!(parsed.max_extract_time_secs, Some(3)); +} diff --git a/tests/math_microbench_extract_report.rs b/tests/math_microbench_extract_report.rs new file mode 100644 index 0000000..acdd9a8 --- /dev/null +++ b/tests/math_microbench_extract_report.rs @@ -0,0 +1,41 @@ +#[path = "../benches/runners/eggplant_rewrite/math_microbenchmark.rs"] +mod typed_math_microbenchmark; + +#[cfg(feature = "rustsat-extract")] +#[test] +fn math_microbench_extract_report_contains_all_backends_with_rendered_terms() { + let rows = typed_math_microbenchmark::run_extract_comparison_with_iters_and_mem_cap(1, 20); + + let methods = rows.iter().map(|row| row.method).collect::>(); + assert_eq!(methods, vec!["default", "eboost", "layered", "rustsat"]); + + for row in rows { + assert_eq!(row.requested_rewrite_iters, 1); + assert!(row.executed_rewrite_iters <= row.requested_rewrite_iters); + assert!(!row.run_ruleset_note.is_empty()); + assert_eq!(row.max_rewrite_mem_gib, 20); + assert!(row.rewrite_peak_memory_bytes <= u64::MAX); + let _extract_peak_memory_bytes = row.extract_peak_memory_bytes; + assert!( + !row.rendered.is_empty(), + "rendered expression should not be empty for {}", + row.method + ); + assert!( + row.elapsed.as_nanos() > 0, + "elapsed time should be captured for {}", + row.method + ); + assert!( + !row.svg_path.is_empty(), + "svg path should be recorded for {}", + row.method + ); + assert!( + std::path::Path::new(&row.svg_path).exists(), + "svg file should exist for {} at {}", + row.method, + row.svg_path + ); + } +} diff --git a/tests/math_microbench_no_calculus.rs b/tests/math_microbench_no_calculus.rs new file mode 100644 index 0000000..0959c2b --- /dev/null +++ b/tests/math_microbench_no_calculus.rs @@ -0,0 +1,115 @@ +#[path = "../benches/runners/eggplant_rewrite/math_microbenchmark_no_calculus.rs"] +mod typed_math_microbenchmark_no_calculus; + +use std::sync::{Mutex, OnceLock}; + +fn test_guard() -> &'static Mutex<()> { + static GUARD: OnceLock> = OnceLock::new(); + GUARD.get_or_init(|| Mutex::new(())) +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn typed_math_microbenchmark_no_calculus_stats_are_non_empty() { + let _guard = test_guard().lock().unwrap(); + let stats = typed_math_microbenchmark_no_calculus::run_and_collect_stats(false); + assert!(stats.total_num_tuples > 0); + assert!( + stats + .table_sizes + .iter() + .any(|(name, size)| *name == "MAdd" && *size > 0) + ); + assert!( + stats + .table_sizes + .iter() + .all(|(name, _)| *name != "MDiff" && *name != "MIntegral"), + "no-calculus benchmark should not expose MDiff/MIntegral tables" + ); +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn no_calculus_extract_report_omits_diff_and_integral_forms() { + let _guard = test_guard().lock().unwrap(); + let rows = + typed_math_microbenchmark_no_calculus::run_extract_comparison_with_iters_and_mem_cap(1, 20); + assert_eq!(rows.len(), 4); + for row in rows { + assert!( + !row.rendered.contains("MDiff") && !row.rendered.contains("MIntegral"), + "no-calculus extraction should not contain MDiff/MIntegral: {}", + row.rendered + ); + } +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn no_calculus_timeline_contains_one_point_per_iteration() { + let _guard = test_guard().lock().unwrap(); + let report = + typed_math_microbenchmark_no_calculus::run_extract_timeline_with_iters_and_mem_cap(2, 20); + assert_eq!(report.requested_rewrite_iters, 2); + assert_eq!(report.points.len(), 2); + for point in report.points { + assert!(point.iteration >= 1); + assert_eq!(point.extracts.len(), 4); + assert!(!point.rule_matches.is_empty()); + for metric in point.extracts { + assert!(metric.cost.is_some()); + } + } +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn no_calculus_timeline_honors_selected_extractors() { + let _guard = test_guard().lock().unwrap(); + let report = typed_math_microbenchmark_no_calculus::run_extract_timeline_with_options( + 1, + 20, + &["default".to_string(), "layered".to_string()], + Some(1), + ); + assert_eq!(report.selected_extractors, vec!["default", "layered"]); + assert_eq!(report.max_extract_time_secs, Some(1)); + assert_eq!(report.points.len(), 1); + assert_eq!(report.points[0].extracts.len(), 2); + assert_eq!(report.points[0].extracts[0].method, "default"); + assert_eq!(report.points[0].extracts[1].method, "layered"); +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn no_calculus_progress_callback_receives_rewrite_and_extract_events() { + let _guard = test_guard().lock().unwrap(); + let mut saw_rewrite = false; + let mut saw_extract = false; + let _rows = typed_math_microbenchmark_no_calculus::run_extract_comparison_with_iters_and_mem_cap_and_progress( + 1, + 20, + |event| match event { + typed_math_microbenchmark_no_calculus::ProgressEvent::RewriteIterationComplete { .. } => { + saw_rewrite = true; + } + typed_math_microbenchmark_no_calculus::ProgressEvent::ExtractPhaseStart { .. } => { + saw_extract = true; + } + _ => {} + }, + ); + assert!(saw_rewrite); + assert!(saw_extract); +} + +#[test] +fn no_calculus_cancel_neg_add_rewrites_to_zero() { + let _guard = test_guard().lock().unwrap(); + let rendered = typed_math_microbenchmark_no_calculus::run_cancel_neg_add_rewrite_smoke( + 1, + eggplant::egglog::extract::TreeAdditiveCostModel::default(), + ); + assert_eq!(rendered, "(MConst 0)"); +} diff --git a/tests/math_microbench_quarto_report.rs b/tests/math_microbench_quarto_report.rs new file mode 100644 index 0000000..1c0b3de --- /dev/null +++ b/tests/math_microbench_quarto_report.rs @@ -0,0 +1,30 @@ +use std::path::PathBuf; +use std::process::Command; + +#[test] +fn quarto_report_builder_generates_qmd() { + let manifest_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")); + let json_path = manifest_dir.join("target/math_microbenchmark_no_calculus_timeline.json"); + let out_dir = manifest_dir.join("target/math_microbenchmark_no_calculus_quarto"); + let script = manifest_dir.join("tools/build_math_microbenchmark_quarto_report.py"); + + let status = Command::new("python3") + .arg(script) + .arg(&json_path) + .arg("--out-dir") + .arg(&out_dir) + .status() + .expect("python3 should launch quarto report builder"); + assert!( + status.success(), + "quarto report builder should exit successfully" + ); + + let qmd_path = out_dir.join("report.qmd"); + assert!(qmd_path.exists(), "builder should create report.qmd"); + let qmd = std::fs::read_to_string(&qmd_path).expect("qmd should be readable"); + assert!( + qmd.contains("Math Microbenchmark Timeline Report"), + "qmd should contain the report title" + ); +} diff --git a/tests/math_microbench_timeline_cli.rs b/tests/math_microbench_timeline_cli.rs new file mode 100644 index 0000000..711308f --- /dev/null +++ b/tests/math_microbench_timeline_cli.rs @@ -0,0 +1,56 @@ +#[cfg(feature = "rustsat-extract")] +#[path = "../examples/math_microbenchmark_no_calculus_timeline_export.rs"] +mod math_microbenchmark_no_calculus_timeline_export; + +#[cfg(feature = "rustsat-extract")] +#[test] +fn timeline_cli_accepts_version_nickname() { + let parsed = math_microbenchmark_no_calculus_timeline_export::parse_args([ + "timeline-export", + "--version-nickname", + "cancel-neg-v1", + ]); + assert_eq!(parsed.version_nickname.as_deref(), Some("cancel-neg-v1")); +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn timeline_cli_accepts_extractor_filter_and_timeout() { + let parsed = math_microbenchmark_no_calculus_timeline_export::parse_args([ + "timeline-export", + "--extractor", + "default,layered", + "--max-extract-time", + "7", + ]); + assert_eq!(parsed.extractors, vec!["default", "layered"]); + assert_eq!(parsed.max_extract_time_secs, Some(7)); +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn timeline_cli_accepts_md_out() { + let parsed = math_microbenchmark_no_calculus_timeline_export::parse_args([ + "timeline-export", + "--md-out", + "target/no_calculus_report.md", + ]); + assert_eq!( + parsed.md_out.as_deref(), + Some("target/no_calculus_report.md") + ); +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn timeline_cli_accepts_plot_out() { + let parsed = math_microbenchmark_no_calculus_timeline_export::parse_args([ + "timeline-export", + "--plot-out", + "target/no_calculus_plot.png", + ]); + assert_eq!( + parsed.plot_out.as_deref(), + Some("target/no_calculus_plot.png") + ); +} diff --git a/tests/nncase_clamp_cli.rs b/tests/nncase_clamp_cli.rs new file mode 100644 index 0000000..8452925 --- /dev/null +++ b/tests/nncase_clamp_cli.rs @@ -0,0 +1,82 @@ +#[cfg(feature = "rustsat-extract")] +#[path = "../src/benchmarks/mod.rs"] +mod benchmarks; + +#[cfg(feature = "rustsat-extract")] +use crate::benchmarks::nncase_clamp_microbenchmark; + +#[cfg(feature = "rustsat-extract")] +#[test] +fn clamp_extract_cli_accepts_iter_memory_and_extractors() { + let parsed = nncase_clamp_microbenchmark::parse_extract_args([ + "extract-bench", + "--max_iter=8", + "--max_mem=9", + "--extractor=default,layered", + "--max-extract-time=3", + ]); + assert_eq!(parsed.rewrite_iters, 8); + assert_eq!(parsed.max_rewrite_mem_gib, 9); + assert_eq!(parsed.extractors, vec!["default", "layered"]); +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn clamp_timeline_cli_accepts_version_nickname_and_json_out() { + let parsed = nncase_clamp_microbenchmark::parse_timeline_args([ + "timeline-export", + "--version-nickname", + "clamp-v1", + "--json-out", + "target/clamp.json", + "--extractor", + "default,layered", + "--max-extract-time", + "7", + ]); + assert_eq!(parsed.version_nickname.as_deref(), Some("clamp-v1")); + assert_eq!(parsed.json_out, "target/clamp.json"); + assert_eq!(parsed.extractors, vec!["default", "layered"]); +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn clamp_example_uses_microbenchmark_workload_spec() { + let spec = nncase_clamp_microbenchmark::workload_spec(); + assert_eq!(spec.positioning.benchmark_case, "clamp"); + assert_eq!(spec.target_root, "Relu(Conv2D(input, w0))"); + assert_eq!( + spec.op_costs, + &[ + ("Input", 0), + ("Weight", 0), + ("Conv2D", 12), + ("Relu", 4), + ("Relu6", 4), + ("ClampZeroInf", 2), + ("ClampZeroSix", 2), + ("FusedConv2D", 1), + ] + ); + assert_eq!( + spec.rewrite_rules, + &[ + "relu_to_clamp", + "relu6_to_clamp", + "fold_nested_clamp", + "fuse_clamp_conv2d", + ] + ); + assert_eq!( + spec.rule_witnesses, + &[ + ("relu_to_clamp", "Relu(Conv2D(input, w0))"), + ("relu6_to_clamp", "Relu6(Conv2D(input, w0))"), + ( + "fold_nested_clamp", + "ClampZeroInf(ClampZeroInf(Conv2D(input, w0)))", + ), + ("fuse_clamp_conv2d", "ClampZeroInf(Conv2D(input, w0))"), + ] + ); +} diff --git a/tests/nncase_clamp_microbench.rs b/tests/nncase_clamp_microbench.rs new file mode 100644 index 0000000..96c7c6d --- /dev/null +++ b/tests/nncase_clamp_microbench.rs @@ -0,0 +1,100 @@ +#[cfg(feature = "rustsat-extract")] +#[path = "../src/benchmarks/mod.rs"] +mod benchmarks; + +#[cfg(feature = "rustsat-extract")] +use crate::benchmarks::nncase_clamp_microbenchmark; + +#[cfg(feature = "rustsat-extract")] +use std::sync::{Mutex, OnceLock}; + +#[cfg(feature = "rustsat-extract")] +fn test_guard() -> &'static Mutex<()> { + static GUARD: OnceLock> = OnceLock::new(); + GUARD.get_or_init(|| Mutex::new(())) +} + +#[cfg(feature = "rustsat-extract")] +fn total_rule_matches( + report: &nncase_clamp_microbenchmark::ExtractTimelineReport, + rule: &str, +) -> usize { + let prefixed = format!("@{rule}"); + report + .points + .iter() + .filter_map(|point| { + point + .rule_matches + .get(rule) + .or_else(|| point.rule_matches.get(prefixed.as_str())) + }) + .sum() +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn clamp_extract_report_contains_all_backends_with_svg_outputs() { + let _guard = test_guard().lock().unwrap_or_else(|err| err.into_inner()); + let rows = nncase_clamp_microbenchmark::run_extract_comparison_with_iters_and_mem_cap(1, 20); + let methods = rows.iter().map(|row| row.method).collect::>(); + assert_eq!(methods, vec!["default", "eboost", "layered", "rustsat"]); + for row in rows { + assert!(!row.rendered.is_empty()); + assert!(row.extract_peak_memory_bytes.is_some()); + assert!(std::path::Path::new(&row.svg_path).exists()); + } +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn clamp_timeline_contains_points_for_iterations_zero_through_eight() { + let _guard = test_guard().lock().unwrap_or_else(|err| err.into_inner()); + let report = nncase_clamp_microbenchmark::run_extract_timeline_with_iters_and_mem_cap(9, 20); + assert_eq!(report.points.len(), 9); + assert_eq!(report.points.first().map(|p| p.iteration), Some(0)); + assert_eq!(report.points.last().map(|p| p.iteration), Some(8)); +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn clamp_timeline_exercises_every_advertised_rule() { + let _guard = test_guard().lock().unwrap_or_else(|err| err.into_inner()); + let report = nncase_clamp_microbenchmark::run_extract_timeline_with_iters_and_mem_cap(9, 20); + let spec = nncase_clamp_microbenchmark::workload_spec(); + let witness_rules = spec + .rule_witnesses + .iter() + .map(|(rule, _)| *rule) + .collect::>(); + assert_eq!(witness_rules, spec.rewrite_rules); + let observed = report + .points + .iter() + .flat_map(|point| { + point + .rule_matches + .iter() + .map(move |(rule, count)| (point.iteration, rule.clone(), *count)) + }) + .collect::>(); + for rule in spec.rewrite_rules { + let matches = total_rule_matches(&report, rule); + assert!( + matches > 0, + "advertised rule `{rule}` was never exercised; observed matches: {observed:?}" + ); + } +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn clamp_smoke_extract_prefers_fused_conv_over_relu_wrapper() { + let _guard = test_guard().lock().unwrap_or_else(|err| err.into_inner()); + let rendered = nncase_clamp_microbenchmark::run_clamp_rewrite_smoke( + 4, + eggplant::egglog::extract::TreeAdditiveCostModel::default(), + ); + assert!(rendered.contains("FusedConv2D")); + assert!(!rendered.contains("Relu")); +} diff --git a/tests/nncase_transpose_cli.rs b/tests/nncase_transpose_cli.rs new file mode 100644 index 0000000..d829627 --- /dev/null +++ b/tests/nncase_transpose_cli.rs @@ -0,0 +1,91 @@ +#[cfg(feature = "rustsat-extract")] +#[path = "../src/benchmarks/mod.rs"] +mod benchmarks; + +#[cfg(feature = "rustsat-extract")] +use crate::benchmarks::nncase_transpose_microbenchmark; + +#[cfg(feature = "rustsat-extract")] +#[test] +fn transpose_extract_cli_accepts_iter_memory_and_extractors() { + let parsed = nncase_transpose_microbenchmark::parse_extract_args([ + "extract-bench", + "--max_iter=8", + "--max_mem=9", + "--extractor=default,layered", + "--max-extract-time=3", + ]); + assert_eq!(parsed.rewrite_iters, 8); + assert_eq!(parsed.max_rewrite_mem_gib, 9); + assert_eq!(parsed.extractors, vec!["default", "layered"]); + assert_eq!(parsed.max_extract_time_secs, Some(3)); +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn transpose_timeline_cli_accepts_version_nickname_and_json_out() { + let parsed = nncase_transpose_microbenchmark::parse_timeline_args([ + "timeline-export", + "--version-nickname", + "transpose-v1", + "--json-out", + "target/transpose.json", + "--md-out", + "target/transpose.md", + "--extractor", + "default,layered", + "--max-extract-time", + "7", + ]); + assert_eq!(parsed.version_nickname.as_deref(), Some("transpose-v1")); + assert_eq!(parsed.json_out, "target/transpose.json"); + assert_eq!(parsed.md_out.as_deref(), Some("target/transpose.md")); + assert_eq!(parsed.extractors, vec!["default", "layered"]); + assert_eq!(parsed.max_extract_time_secs, Some(7)); +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn transpose_example_uses_microbenchmark_workload_spec() { + let spec = nncase_transpose_microbenchmark::workload_spec(); + assert_eq!(spec.positioning.benchmark_case, "transpose"); + assert_eq!( + spec.target_root, + "Transpose(Add(Transpose(lhs, swap), Transpose(UnaryExp(rhs), swap)), swap)" + ); + assert_eq!( + spec.op_costs, + &[ + ("Input", 0), + ("PermId", 0), + ("PermSwap", 0), + ("Add", 1), + ("UnaryExp", 2), + ("Transpose", 6), + ] + ); + assert_eq!( + spec.rewrite_rules, + &[ + "combine_binary_transpose", + "combine_unary_transpose", + "fold_two_transposes", + "fold_nop_transpose", + ] + ); + assert_eq!( + spec.rule_witnesses, + &[ + ( + "combine_binary_transpose", + "Add(Transpose(lhs, swap), Transpose(UnaryExp(rhs), swap))", + ), + ("combine_unary_transpose", "UnaryExp(Transpose(aux, swap))"), + ( + "fold_two_transposes", + "Transpose(Transpose(aux, swap), swap)" + ), + ("fold_nop_transpose", "Transpose(aux, id)"), + ] + ); +} diff --git a/tests/nncase_transpose_microbench.rs b/tests/nncase_transpose_microbench.rs new file mode 100644 index 0000000..3431977 --- /dev/null +++ b/tests/nncase_transpose_microbench.rs @@ -0,0 +1,115 @@ +#[cfg(feature = "rustsat-extract")] +#[path = "../src/benchmarks/mod.rs"] +mod benchmarks; + +#[cfg(feature = "rustsat-extract")] +use crate::benchmarks::nncase_transpose_microbenchmark; + +#[cfg(feature = "rustsat-extract")] +use std::sync::{Mutex, OnceLock}; + +#[cfg(feature = "rustsat-extract")] +fn test_guard() -> &'static Mutex<()> { + static GUARD: OnceLock> = OnceLock::new(); + GUARD.get_or_init(|| Mutex::new(())) +} + +#[cfg(feature = "rustsat-extract")] +fn total_rule_matches( + report: &nncase_transpose_microbenchmark::ExtractTimelineReport, + rule: &str, +) -> usize { + let prefixed = format!("@{rule}"); + report + .points + .iter() + .filter_map(|point| { + point + .rule_matches + .get(rule) + .or_else(|| point.rule_matches.get(prefixed.as_str())) + }) + .sum() +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn transpose_extract_report_contains_all_backends_with_svg_outputs() { + let _guard = test_guard().lock().unwrap_or_else(|err| err.into_inner()); + let rows = + nncase_transpose_microbenchmark::run_extract_comparison_with_iters_and_mem_cap(1, 20); + + let methods = rows.iter().map(|row| row.method).collect::>(); + assert_eq!(methods, vec!["default", "eboost", "layered", "rustsat"]); + + for row in rows { + assert_eq!(row.requested_rewrite_iters, 1); + assert!(row.executed_rewrite_iters <= 1); + assert!(!row.rendered.is_empty()); + assert!(row.extract_peak_memory_bytes.is_some()); + assert!(!row.svg_path.is_empty()); + assert!(std::path::Path::new(&row.svg_path).exists()); + } +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn transpose_timeline_contains_points_for_iterations_zero_through_eight() { + let _guard = test_guard().lock().unwrap_or_else(|err| err.into_inner()); + let report = + nncase_transpose_microbenchmark::run_extract_timeline_with_iters_and_mem_cap(9, 20); + assert_eq!(report.requested_rewrite_iters, 9); + assert_eq!(report.points.len(), 9); + assert_eq!(report.points.first().map(|p| p.iteration), Some(0)); + assert_eq!(report.points.last().map(|p| p.iteration), Some(8)); + for point in report.points { + assert_eq!(point.extracts.len(), 4); + assert!(!point.rule_matches.is_empty()); + } +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn transpose_timeline_exercises_every_advertised_rule() { + let _guard = test_guard().lock().unwrap_or_else(|err| err.into_inner()); + let report = + nncase_transpose_microbenchmark::run_extract_timeline_with_iters_and_mem_cap(9, 20); + let spec = nncase_transpose_microbenchmark::workload_spec(); + let witness_rules = spec + .rule_witnesses + .iter() + .map(|(rule, _)| *rule) + .collect::>(); + assert_eq!(witness_rules, spec.rewrite_rules); + let observed = report + .points + .iter() + .flat_map(|point| { + point + .rule_matches + .iter() + .map(move |(rule, count)| (point.iteration, rule.clone(), *count)) + }) + .collect::>(); + for rule in spec.rewrite_rules { + let matches = total_rule_matches(&report, rule); + assert!( + matches > 0, + "advertised rule `{rule}` was never exercised; observed matches: {observed:?}" + ); + } +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn transpose_smoke_extract_prefers_eliminating_redundant_transpose() { + let _guard = test_guard().lock().unwrap_or_else(|err| err.into_inner()); + let rendered = nncase_transpose_microbenchmark::run_transpose_rewrite_smoke( + 3, + eggplant::egglog::extract::TreeAdditiveCostModel::default(), + ); + assert!( + !rendered.contains("Transpose(Transpose"), + "extracted form should fold nested transpose: {rendered}" + ); +} diff --git a/tests/nncase_vectorize_cli.rs b/tests/nncase_vectorize_cli.rs new file mode 100644 index 0000000..e67aa09 --- /dev/null +++ b/tests/nncase_vectorize_cli.rs @@ -0,0 +1,84 @@ +#[cfg(feature = "rustsat-extract")] +#[path = "../src/benchmarks/mod.rs"] +mod benchmarks; + +#[cfg(feature = "rustsat-extract")] +use crate::benchmarks::nncase_vectorize_microbenchmark; + +#[cfg(feature = "rustsat-extract")] +#[test] +fn vectorize_extract_cli_accepts_iter_memory_and_extractors() { + let parsed = nncase_vectorize_microbenchmark::parse_extract_args([ + "extract-bench", + "--max_iter=8", + "--max_mem=9", + "--extractor=default,layered", + "--max-extract-time=3", + ]); + assert_eq!(parsed.rewrite_iters, 8); + assert_eq!(parsed.max_rewrite_mem_gib, 9); + assert_eq!(parsed.extractors, vec!["default", "layered"]); + assert_eq!(parsed.max_extract_time_secs, Some(3)); +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn vectorize_timeline_cli_accepts_version_nickname_and_json_out() { + let parsed = nncase_vectorize_microbenchmark::parse_timeline_args([ + "timeline-export", + "--version-nickname", + "vectorize-v1", + "--json-out", + "target/vectorize.json", + "--extractor", + "default,layered", + "--max-extract-time", + "7", + ]); + assert_eq!(parsed.version_nickname.as_deref(), Some("vectorize-v1")); + assert_eq!(parsed.json_out, "target/vectorize.json"); + assert_eq!(parsed.extractors, vec!["default", "layered"]); +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn vectorize_example_uses_microbenchmark_workload_spec() { + let spec = nncase_vectorize_microbenchmark::workload_spec(); + assert_eq!(spec.positioning.benchmark_case, "vectorize"); + assert_eq!( + spec.target_root, + "LogicalMatMul(LogicalExp(LogicalMatMul(q, k)), v)" + ); + assert_eq!( + spec.op_costs, + &[ + ("Input", 0), + ("Flat", 0), + ("Blocked", 0), + ("LogicalMatMul", 12), + ("LogicalExp", 6), + ("Pack", 3), + ("Unpack", 3), + ("PackedMatMul", 2), + ("PackedExp", 1), + ] + ); + assert_eq!( + spec.rewrite_rules, + &[ + "meta_pack_matmul", + "meta_pack_exp", + "fold_nop_pack", + "fold_nop_unpack", + ] + ); + assert_eq!( + spec.rule_witnesses, + &[ + ("meta_pack_matmul", "LogicalMatMul(q, k)"), + ("meta_pack_exp", "LogicalExp(Unpack(q, blocked))"), + ("fold_nop_pack", "Pack(Unpack(v, blocked), blocked)"), + ("fold_nop_unpack", "Unpack(Pack(k, blocked), blocked)"), + ] + ); +} diff --git a/tests/nncase_vectorize_microbench.rs b/tests/nncase_vectorize_microbench.rs new file mode 100644 index 0000000..6a07ff9 --- /dev/null +++ b/tests/nncase_vectorize_microbench.rs @@ -0,0 +1,103 @@ +#[cfg(feature = "rustsat-extract")] +#[path = "../src/benchmarks/mod.rs"] +mod benchmarks; + +#[cfg(feature = "rustsat-extract")] +use crate::benchmarks::nncase_vectorize_microbenchmark; + +#[cfg(feature = "rustsat-extract")] +use std::sync::{Mutex, OnceLock}; + +#[cfg(feature = "rustsat-extract")] +fn test_guard() -> &'static Mutex<()> { + static GUARD: OnceLock> = OnceLock::new(); + GUARD.get_or_init(|| Mutex::new(())) +} + +#[cfg(feature = "rustsat-extract")] +fn total_rule_matches( + report: &nncase_vectorize_microbenchmark::ExtractTimelineReport, + rule: &str, +) -> usize { + let prefixed = format!("@{rule}"); + report + .points + .iter() + .filter_map(|point| { + point + .rule_matches + .get(rule) + .or_else(|| point.rule_matches.get(prefixed.as_str())) + }) + .sum() +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn vectorize_extract_report_contains_all_backends_with_svg_outputs() { + let _guard = test_guard().lock().unwrap_or_else(|err| err.into_inner()); + let rows = + nncase_vectorize_microbenchmark::run_extract_comparison_with_iters_and_mem_cap(1, 20); + let methods = rows.iter().map(|row| row.method).collect::>(); + assert_eq!(methods, vec!["default", "eboost", "layered", "rustsat"]); + for row in rows { + assert!(!row.rendered.is_empty()); + assert!(row.extract_peak_memory_bytes.is_some()); + assert!(std::path::Path::new(&row.svg_path).exists()); + } +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn vectorize_timeline_contains_points_for_iterations_zero_through_eight() { + let _guard = test_guard().lock().unwrap_or_else(|err| err.into_inner()); + let report = + nncase_vectorize_microbenchmark::run_extract_timeline_with_iters_and_mem_cap(9, 20); + assert_eq!(report.points.len(), 9); + assert_eq!(report.points.first().map(|p| p.iteration), Some(0)); + assert_eq!(report.points.last().map(|p| p.iteration), Some(8)); +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn vectorize_timeline_exercises_every_advertised_rule() { + let _guard = test_guard().lock().unwrap_or_else(|err| err.into_inner()); + let report = + nncase_vectorize_microbenchmark::run_extract_timeline_with_iters_and_mem_cap(9, 20); + let spec = nncase_vectorize_microbenchmark::workload_spec(); + let witness_rules = spec + .rule_witnesses + .iter() + .map(|(rule, _)| *rule) + .collect::>(); + assert_eq!(witness_rules, spec.rewrite_rules); + let observed = report + .points + .iter() + .flat_map(|point| { + point + .rule_matches + .iter() + .map(move |(rule, count)| (point.iteration, rule.clone(), *count)) + }) + .collect::>(); + for rule in spec.rewrite_rules { + let matches = total_rule_matches(&report, rule); + assert!( + matches > 0, + "advertised rule `{rule}` was never exercised; observed matches: {observed:?}" + ); + } +} + +#[cfg(feature = "rustsat-extract")] +#[test] +fn vectorize_smoke_extract_prefers_packed_pipeline_without_pack_unpack_ping_pong() { + let _guard = test_guard().lock().unwrap_or_else(|err| err.into_inner()); + let rendered = nncase_vectorize_microbenchmark::run_vectorize_rewrite_smoke( + 4, + eggplant::egglog::extract::TreeAdditiveCostModel::default(), + ); + assert!(rendered.contains("Packed")); + assert!(!rendered.contains("Pack (Unpack")); +} diff --git a/tests/timeline_markdown_report.rs b/tests/timeline_markdown_report.rs new file mode 100644 index 0000000..51e472d --- /dev/null +++ b/tests/timeline_markdown_report.rs @@ -0,0 +1,170 @@ +#[cfg(feature = "timeline-plot")] +use eggplant::prelude::write_timeline_plot_png; +use eggplant::prelude::{ + TimelineExportCliArgs, render_timeline_markdown_report, + render_timeline_markdown_report_with_plot, timeline_markdown_output_path, + timeline_plot_output_path, +}; +use serde_json::json; + +fn sample_timeline_report() -> serde_json::Value { + json!({ + "version_nickname": "cancel-neg-v1", + "selected_extractors": ["default", "layered"], + "max_extract_time_secs": 7, + "requested_rewrite_iters": 1, + "executed_rewrite_iters": 1, + "max_rewrite_mem_gib": 12, + "stopped_early_due_to_memory_cap": false, + "points": [ + { + "iteration": 1, + "tuple_count": 3, + "rewrite_elapsed_ms": 1.0, + "rewrite_peak_memory_bytes": 1048576, + "rule_matches": {"@demo": 2}, + "extracts": [ + { + "method": "default", + "cost": 0, + "elapsed_ms": 1.0, + "peak_memory_bytes": 1048576, + "svg_path": "target/default.svg", + "timed_out": false + }, + { + "method": "layered", + "cost": null, + "elapsed_ms": null, + "peak_memory_bytes": null, + "svg_path": "n/a", + "timed_out": true + } + ] + } + ] + }) +} + +fn sample_nncase_timeline_report() -> serde_json::Value { + json!({ + "version_nickname": "nncase-clamp", + "benchmark_family": "nncase", + "benchmark_case": "clamp", + "baseline": "nncase egraph implementation", + "comparison_target": "eggplant", + "positioning": "This nncase workload is included because the original nncase egraph implementation is slower than eggplant on this rewrite/extract shape.", + "selected_extractors": ["default"], + "max_extract_time_secs": null, + "requested_rewrite_iters": 1, + "executed_rewrite_iters": 1, + "max_rewrite_mem_gib": 12, + "stopped_early_due_to_memory_cap": false, + "points": [] + }) +} + +#[test] +fn timeline_markdown_report_renders_metadata_rules_and_svg_links() { + let report = sample_timeline_report(); + let md = render_timeline_markdown_report("Math Microbenchmark Timeline", &report).unwrap(); + + assert!(md.contains("# Math Microbenchmark Timeline - cancel-neg-v1")); + assert!(md.contains("| Selected Extractors | default, layered |")); + assert!(md.contains("| Max Extract Time | 7 s |")); + assert!(md.contains("| @demo | 2 |")); + assert!(md.contains("| 1 | 3 | 1.000 | 1.00 |")); + assert!(md.contains("[target/default.svg](target/default.svg)")); + assert!(md.contains("![default iteration 1](target/default.svg)")); + assert!(md.contains("| layered | 3 | 1.000 | 1.00 | NaN | NaN | NaN | true | n/a | n/a |")); +} + +#[test] +fn timeline_markdown_report_renders_nncase_positioning_notes() { + let report = sample_nncase_timeline_report(); + let md = render_timeline_markdown_report("Nncase Clamp Timeline", &report).unwrap(); + + assert!(md.contains("## Benchmark Positioning")); + assert!(md.contains("| Benchmark Family | nncase |")); + assert!(md.contains("| Benchmark Case | clamp |")); + assert!(md.contains("| Baseline | nncase egraph implementation |")); + assert!(md.contains("| Comparison Target | eggplant |")); + assert!( + md.contains( + "the original nncase egraph implementation is slower than eggplant on this rewrite/extract shape" + ) + ); +} + +#[test] +fn timeline_markdown_report_can_embed_plot_image() { + let report = sample_timeline_report(); + let md = render_timeline_markdown_report_with_plot( + "Math Microbenchmark Timeline", + &report, + Some("timeline_plot.png"), + ) + .unwrap(); + + assert!(md.contains("## Timeline Plot")); + assert!(md.contains("![Timeline Plot](timeline_plot.png)")); +} + +#[test] +fn timeline_markdown_output_path_defaults_to_json_path_with_md_extension() { + let args = TimelineExportCliArgs { + rewrite_iters: 1, + max_rewrite_mem_gib: 12, + json_out: "target/demo.timeline.json".to_string(), + md_out: None, + plot_out: None, + version_nickname: None, + extractors: vec!["default".to_string()], + max_extract_time_secs: None, + }; + + assert_eq!( + timeline_markdown_output_path(&args), + std::path::PathBuf::from("target/demo.timeline.md") + ); +} + +#[test] +fn timeline_plot_output_path_defaults_to_json_path_with_png_extension() { + let args = TimelineExportCliArgs { + rewrite_iters: 1, + max_rewrite_mem_gib: 12, + json_out: "target/demo.timeline.json".to_string(), + md_out: None, + plot_out: None, + version_nickname: None, + extractors: vec!["default".to_string()], + max_extract_time_secs: None, + }; + + assert_eq!( + timeline_plot_output_path(&args), + std::path::PathBuf::from("target/demo.timeline.png") + ); +} + +#[cfg(feature = "timeline-plot")] +#[test] +fn timeline_plot_png_writer_creates_png_file() { + let report = sample_timeline_report(); + let output_dir = std::env::temp_dir().join(format!( + "eggplant-timeline-plot-test-{}", + std::process::id() + )); + std::fs::create_dir_all(&output_dir).unwrap(); + let output_path = output_dir.join("timeline_plot.png"); + + write_timeline_plot_png("Math Microbenchmark Timeline", &report, &output_path).unwrap(); + + let bytes = std::fs::read(&output_path).unwrap(); + assert!(bytes.starts_with(&[137, 80, 78, 71, 13, 10, 26, 10])); + assert!(bytes.len() > 1_000); + + let _ = std::fs::remove_file(output_path); + let _ = std::fs::remove_dir(output_dir); +}